#include <iostream>
#include <thread>
#include <regex>
#include <vector>
#include <thread>
#include<future>
#include <chrono>
using namespace std;
void data_preparation_tread(shared_ptr<mutex>& mut, shared_ptr<vector<int>>& data_queue, shared_ptr<condition_variable>& data_cond)
{
while (true)
{
static int x = 0;
x++;
lock_guard<mutex> ld(*mut);
data_queue->push_back(x);
data_cond->notify_one();
chrono::milliseconds ms(1000);
this_thread::sleep_for(ms);
if (x == 10)
break;
}
}
void data_processing_thread(shared_ptr<mutex>& mut, shared_ptr<vector<int>>& data_queue, shared_ptr<condition_variable>& data_cond)
{
while (true)
{
std::unique_lock<mutex> lk(*mut);
data_cond->wait(lk, [=]{
if (data_queue->empty())
{
cout << endl << "Fault wake up" << endl;
}
return !data_queue->empty();
});
int number{};
while (data_queue->size() > 0)
{
number = data_queue->back();
data_queue->pop_back();
cout << "Number:" << number << " " << "Buffer length:" << data_queue->size() << endl;
}
lk.unlock();
if (number == 10)
break;
}
}
int main() {
shared_ptr<mutex> mut = make_shared<mutex>();
shared_ptr<vector<int>> data_queue = make_shared<vector<int>>();
shared_ptr<condition_variable> data_cond = make_shared<condition_variable>();
std::thread processing = thread(data_processing_thread, ref(mut), ref(data_queue), ref(data_cond));
std::thread preparation = thread(data_preparation_tread, ref(mut), ref(data_queue), ref(data_cond));
processing.join();
preparation.join();
return 0;
}
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