Queue overwriting in multi producer multi consumer queue - multithreading

Question

In the following multi producer and single consumer fixed size queue implementation i see the queue being overwritten by producers.
Why is the queue being overwritten?
At this point am not looking at performance of the code but would like to see that every item pushed is consumed and is not lost.
How do i extend this to multi prod multi consumer?
#include <iostream>
#include <thread>
#include <mutex>
#include <utility>
#include <ctime>
#include <condition_variable>
#include <stdlib.h>
#include <unistd.h>
#include <atomic>
using namespace std;
enum class returncode { QUEUE_EMPTY, QUEUE_FULL,SUCCESS } ;
atomic_long d;
class Queue {
private:
long* qdata;
atomic_size_t length;
atomic_size_t head;
atomic_size_t tail ;
atomic_size_t size;
std::mutex qmutex;
std::condition_variable qcond ;
public:
Queue(size_t len): length(len)
{
qdata=new long[length] ;
head=0;
tail=0;
size=0;
srand(time(NULL));
}
bool isfull()
{
if( size == length )
return true;
return false;
}
bool isempty()
{
if(size == 0)
return true;
return false;
}
returncode push(long data)
{
std::unique_lock<std::mutex> qguard(qmutex);
if(size == length) //if isfull
return returncode::QUEUE_FULL ;
qdata[head]=data;
head = (head+1) % length;
size += 1 ;
qcond.notify_one();
qguard.unlock(); //Should the unlock come before notify_one?
return returncode::SUCCESS;
}
//Its the users responsibility to check isempty before calling front.
//Read function
long front(void)
{
std::unique_lock<std::mutex> qguard(qmutex);
//if isempty
if( size == 0 )
return 0;
long d=qdata[tail];
return d;
}
void pop(void)
{
std::thread::id thisthreadid = std::this_thread::get_id();
std::unique_lock<std::mutex> qguard(qmutex);
while(size == 0 ) // check condition to be safe against spurious wakes
{
qcond.wait(qguard);// release lock and go join the waiting thread queue
return;
}
tail =(tail+1) % length;
size -= 1;
}
};
void produce(Queue* q)
{
while(true)
{
d++;
q->push(d) ;
//sleep(1);
}
}
void consume(Queue* q)
{
while(true){
//usleep(1000);
cout <<"Consume: Pop " << q->front() <<endl;
q->pop();
}
}
int main(int argc, char** argv )
{
Queue q(50);
d=0;
int nprods=4;
int nconsu=1;
std::thread producers[nprods];
std::thread consumers[nconsu];
for (int i=0; i < nprods ; ++i)
producers[i] = std::thread(produce, &q);
for (int i=0; i < nconsu ; ++i)
consumers[i] = std::thread(consume, &q);
for (int i=0; i<nprods; ++i)
producers[i].join();
for (int i=0; i<nconsu; ++i)
consumers[i].join();
return 0;
}
Output:
Consume: Pop 1
Consume: Pop 2
... Sequential all upto the queue size and then q is over written.
Consume: Pop 49
Consume: Pop 50
Consume: Pop 51
Consume: Pop 52
Consume: Pop 53
Consume: Pop 54
Consume: Pop 55
Consume: Pop 56
Consume: Pop 64 --> 57 to 63 lost
Consume: Pop 72 --> 65 to 71 lost
Consume: Pop 81
Consume: Pop 89
Consume: Pop 97
Consume: Pop 105