implementing a thread-safe queue

this is my implementation. feel free to give me commands.

#include <pthread.h>
#include <deque>
#include <exception>

/* exception class for pop() with empty queue */
class ReadEmptyQueue : public std::exception {
public:
    virtual const char* what() const throw() {
        return "Queue is empty!";
    }
};

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
    explicit Queue():mutex(PTHREAD_MUTEX_INITIALIZER), container(new
std::deque<T>())
    {}

    // destructor
    virtual ~Queue(){
        delete container;
    }

    // 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;
    }
};

Thanks!

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