When I use thread and mutex, C++ occur Memory leak - c++

Question

I want store integer to write_odd_queue, then popping integer from another thread.
data_prepation_thread function will store integer to write_odd_queue.
handle_odd function will pop integer from write_odd_queue.
When I write Sleep(10), memory will not increase.
When I comment this code, memory will increase.
Please help me solve this problem.
#include <iostream>
#include <vector>
#include <thread>
#include <random>
#include <windows.h>
#include <time.h>
#include <mutex>
#include <queue>
#include <condition_variable>
using namespace std;
queue<int> write_odd_queue;
mutex write_odd_mutux;
void handle_odd()
{
while (true)
{
int i;
{
lock_guard<mutex> lk(write_odd_mutux);
if (!write_odd_queue.empty())
{
i = write_odd_queue.front();
write_odd_queue.pop();
cout << "test size " << write_odd_queue.empty() << " ";
}
else
{
continue;
}
}
cout << "odd " << i << endl;
Sleep(500);
}
}
void data_prepation_thread()
{
int i = 0;
while (true)
{
i++;
unique_lock<mutex> lk(write_odd_mutux);
write_odd_queue.push(i);
lk.unlock();
// comment Sleep(10), memory will not increase.
//Sleep(10);
}
}
int main()
{
vector<thread> vec;
thread t1(handle_odd);
vec.push_back(move(t1));
data_prepation_thread();
auto it = vec.begin();
for (; it != vec.end(); ++it)
{
it->join();
}
return 0;
}

Answer 1

You are removing things from the queue with a delay of 500 milliseconds, and pushing them on to the queue with no delay - this means the queue will grow, as the frequency of your pops is not matching that of your pushes. Adding a delay to the pushes will reduce the growth, so that it may not be obvious for short runs of the program.

Answer 2

This is solution to avoid Sleep() in both functions using condition variables:
queue<int> write_odd_queue;
mutex write_odd_mutux;
condition_variable data_ready;
condition_variable queue_ready;
bool stopped = false;
const size_t max_size = 1024;
const size_t min_size = 512;
void handle_odd()
{
unique_lock<mutex> lk(write_odd_mutux);
while (!stopped)
{
if( write_odd_queue.empty() ) {
data_ready.wait( lk );
continue;
}
int i = write_odd_queue.front();
write_odd_queue.pop();
if( write_odd_queue.size() == min_size )
queue_ready.notify_one();
cout << "test size " << write_odd_queue.empty() << " ";
lk.unlock();
cout << "odd " << i << endl;
lk.lock();
}
}
void data_prepation_thread()
{
int i = 0;
while (!stopped)
{
unique_lock<mutex> lk(write_odd_mutux);
if( write_odd_queue.size() >= max_size ) {
queue_ready.wait( lk );
continue;
}
write_odd_queue.push(++i);
if( write_odd_queue.size() == 1 )
data_ready.notify_all();
}
}
void stop()
{
unique_lock<mutex> lk(write_odd_mutux);
stopped = true;
data_ready.notify_all();
queue_ready.notify_all();
}
This will prevent queue to grow bigger than max_size and reenable pushing when size drops to min_size. Also there is no unnecessary delay in processing would be involved, as you would have with Sleep(500).