text: Q:
  
  Lockless Deque in Win32 C++
  
  I'm pretty new to lockless data structures, so for an exercise I wrote (What I hope functions as) a bounded lockless deque (No resizing yet, just want to get the base cases working). I'd just like to have some confirmation from people who know what they're doing as to whether I've got the right idea and/or how I might improve this.
  class LocklessDeque
  {
    public:
  
      LocklessDeque() : m_empty(false),
                        m_bottom(0),
                        m_top(0) {}
  
      ~LocklessDeque()
      {
        // Delete remaining tasks
        for( unsigned i = m_top; i < m_bottom; ++i )
          delete m_tasks[i];
      }
  
      void PushBottom(ITask* task)
      {
        m_tasks[m_bottom] = task;
  
        InterlockedIncrement(&m_bottom);
      }
  
      ITask* PopBottom()
      {
        if( m_bottom - m_top > 0 )
        {
          m_empty = false;
  
          InterlockedDecrement(&m_bottom);
  
          return m_tasks[m_bottom];
        }
  
        m_empty = true;
  
        return NULL;
      }
  
      ITask* PopTop()
      {
        if( m_bottom - m_top > 0 )
        {
          m_empty = false;
  
          InterlockedIncrement(&m_top);
  
          return m_tasks[m_top];
        }
  
        m_empty = true;
  
        return NULL;
      }
  
      bool IsEmpty() const
      {
        return m_empty;
      }
  
    private:
  
      ITask* m_tasks[16];
  
      bool m_empty;
  
      volatile unsigned m_bottom;
      volatile unsigned m_top;
  
  };
  
  A:
  
  Looking at this I would think this would be a problem:
  void PushBottom(ITask* task)
  {
    m_tasks[m_bottom] = task;
    InterlockedIncrement(&m_bottom);
  }
  
  If this is used in an actual multithreaded environment I would think you'd collide when setting m_tasks[m_bottom].  Think of what would happen if you have two threads trying to do this at the same time - you couldn't be sure of which one actually set m_tasks[m_bottom].
  Check out this article which is a reasonable discussion of a lock-free queue.
  
  