thread safe

I have a monitor like class and a thread-safe queue:

class Monitor {
public:
     void lock();
     void unlock();
     wait();
     signal();
    ...
};

class MTQueue {
public:
     void put();
     void get();
     ...
private:
     std::queue<item> queue_
     Monitor getLock_;
     Monitor putLock_;
     Monitor emptyLock_;
     Monitor serializeLock_;
     ...
};

Here is the get() and put() implementation:

void put()
{
     putLock_.lock();
     queue_.push(item);
     emptyLock_.signal();
     putLock_.unlock();
}

void get()
{
     getLock_.lock();
     while (queue_.empty()) emptyLock_.wait();
     item = queue_.front();
     queue_.pop();
     getLock_.unlock();
}

Are the put() and get() thread safe? I used two locks for
serialization and one lock for signaling. This allows two threads
access to the queue: one for put and the other for get. Normal
implementation would use only one lock and allows only one thread to
access queue:

void put()
{
     serializeLock_.lock();
     queue_.push(item);
     serializeLock_.signal();
     serializeLock_.unlock();
}

void get()
{
     serializeLock_.lock();
     while (queue_.empty()) serializeLock_.wait();
     item = queue_.front();
     queue_.pop();
     serializeLock_.unlock();
}

Which is the right way to implemt the put() and get()? Thanks in
advance.

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