Re: implementing a thread-safe queue

On May 14, 3:29 am, itcecsa <itce...@gmail.com> wrote:


1. Initialization of member objects in constructor should be in the
same order that they are listed in the class: container before mutex.
2. The default destructor should not be defined as explicit.
3. There is no need to use a pointer to the deque container.

Changes I would make (before testing):

template <class T>
class Queue
{
private:
    std::deque<T> container; // container for the elements
    pthread_mutex_t mutex; // mutex for sync the queue
    Queue(const Queue& q); // disable copy constructor
    Queue& operator= (const Queue& q); // disable assign operator
public:
    // to make it simple, this is the only constructor for Queue instance
    Queue() : mutex(PTHREAD_MUTEX_INITIALIZER)
    {}
    virtual ~Queue()
    {}
    // number of elements
    typename std::deque<T>::size_type size() const
    {
        return container.size();
    }
    //is queue empty?
    bool empty() const
    {
        return container.empty();
    }
    // insert element into the queue
    void push(const T& elem)
    {
        pthread_mutex_lock(&mutex);
        container.push_back(elem);
        pthread_mutex_unlock(&mutex);
    }
    // pop element from the top of the queue
    T pop()
    {
        pthread_mutex_lock(&mutex);
        if(container.empty())
        {
            throw ReadEmptyQueue();
        }
        T elem = container.front();
        container.pop_front();
        pthread_mutex_unlock(&mutex);
        return elem;
    }
};

For is fairly simple example of this see Tqueue ?Thinking in C++? by
Bruce Eeckel.
http://www.mindview.net/Books/TICPP/ThinkingInCPP2e.html

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]