deadlock in producers/consumers queue - c++

Question

I try to solve one interesting problem which is described below:
Write a console application which has N producers (N=1…10), M
consumers (M=1…10) and one data queue. Each producer and consumer is a
separate thread and all threads are working concurrently. Producer
thread sleeps 0…100 milliseconds randomly then it wakes up and
generates a random number between 1 and 100 and then puts this number
to data queue. Consumer thread sleeps 0…100 milliseconds randomly and
then wakes up and takes the number from the queue and saves it to the
output ‘data.txt’ file. All numbers are appended in the file and all
they are comma delimited (for example 4,67,99,23,…). When producer
thread puts the next number to data queue it checks the size of data
queue, and if it is >=100 the producer thread is blocked until the
number of elements gets <= 80. When consumer thread wants to take the
next number from data queue and no elements in it, consumer thread is
blocked until new element is added to data queue by a producer.
When we start application we need to insert the N (number of
producers) and the M (number of consumers) after which program starts
all threads. It should print current number of elements of data queue
in each second. When we stop program it should interrupt all producers
and wait for all consumers to save all queued data then program exits.
To solve this except all I wrote the thread-safe queue
template <class T>
class global::safe_queue
{
private:
sync* m_sync;
size_t m_lcorner;
size_t m_rcorner;
std::queue<T> m_data;
public:
safe_queue(sync* snc, size_t lcorn, size_t rcorn) :
m_sync(snc),
m_lcorner(lcorn),
m_rcorner(rcorn) {}
~safe_queue()
{
m_sync->lock();
while (m_data.size()){
m_data.pop();
}
m_sync->unlock();
}
size_t size() const
{
m_sync->lock();
size_t sz = m_data.size();
m_sync->unlock();
return sz;
}
size_t front() const
{
m_sync->lock();
T item = m_data.front();
m_sync->unlock();
return item;
}
void push(T item)
{
m_sync->lock();
while(m_data.size() >= m_rcorner) {
m_sync->unlock();
usleep(5);
m_sync->lock();
// conditional wait
//m_sync->wait();
}
m_data.push(item);
if(m_data.size() == 1) {
m_sync->unlock();
// conditional signal
//m_sync->signal();
}
m_sync->unlock();
}
T pop()
{
m_sync->lock();
while(m_data.size() == 0) {
m_sync->unlock();
usleep(5);
m_sync->lock();
// conditional wait
//m_sync->wait();
}
T item = m_data.front();
if(m_data.size() <= m_lcorner) {
m_sync->unlock();
// conditional signal
// m_sync->signal();
}
m_data.pop();
m_sync->unlock();
return item;
}
};
But as a result I get deadlock. What is wrong ?