Using std::async() & std::move() to pass data to another thread asynchronously - c++

Question

I really want to see how can those two thread functions RunThread1() & RunThread1() can run in parallel. That RunThread2() is blocked everytime RunThread1() executes or vice a versa.
I do not want to wait until future finishes hence I am using std::async along with std::move
I am using scoped_lock but I don't see that is a problem here.
I am designing an asynchronous response processing engine, one thread inserts data while another thread reads it from other end.
Any suggestions where that problem might be? Any suggestions on overall design.
#include <windows.h>
#include <string>
#include <iostream>
#include <vector>
#include <deque>
#include <chrono>
#include <thread>
#include <future>
#include <boost/scoped_ptr.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
using namespace std;
using namespace boost;
template<typename R>
bool Is_future_ready(std::future<R> const& f)
{
return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
}
std::vector<std::future<void>> pending_futures;
class A
{
private:
boost::thread* myFunc1Thread;
boost::thread* myFunc2Thread;
public:
A()
{
myFunc1Thread = nullptr;
myFunc2Thread = nullptr;
}
void RunThreads();
void RunThread1();
void RunThread2();
void PopulateResponses(vector<string> responses);
void PopulateResponse(string response);
struct Record
{
char response[128];
Record(const char* response)
{
memset(this->response,0,sizeof(this->response));
strcpy(this->response, response);
}
~Record()
{
}
Record& operator= (const Record& cmd)
{
if(this == &cmd) // Same object?
{
return *this;
}
memset(this->response,0,sizeof(this->response));
strcpy(this->response, cmd.response);
return *this;
}
};
typedef deque<Record> RecordsQueue;
};
boost::mutex ResponseMutex;
A::RecordsQueue Records;
void A::RunThreads()
{
myFunc1Thread = new boost::thread(boost::bind(&A::RunThread1, this));
HANDLE threadHandle1 = myFunc1Thread->native_handle();
SetThreadPriority(threadHandle1, THREAD_PRIORITY_NORMAL);
myFunc2Thread = new boost::thread(boost::bind(&A::RunThread2, this));
HANDLE threadHandle2 = myFunc2Thread->native_handle();
SetThreadPriority(threadHandle2, THREAD_PRIORITY_NORMAL);
myFunc1Thread->join();
myFunc2Thread->join();
}
void A::PopulateResponse(string response)
{
Records.push_back(Record(response.c_str()));
}
void A::PopulateResponses(vector<string> responses)
{
boost::mutex::scoped_lock lock(ResponseMutex);
std::for_each(responses.begin(), responses.end(), bind1st(mem_fun(&A::PopulateResponse), this));
}
void A::RunThread1()
{
int i = 0;
while(true)
{
vector<string> responses;
responses.push_back(to_string(i));
cout<< "Added: " << to_string(i) << endl;
i++;
pending_futures.erase(std::remove_if( pending_futures.begin(), pending_futures.end(), Is_future_ready<void>), pending_futures.end());
auto f = std::async (std::launch::async, &A::PopulateResponses, this, responses);
pending_futures.push_back(std::move(f));
}
}
void A::RunThread2()
{
while(true)
{
boost::mutex::scoped_lock lock(ResponseMutex);
if(!Records.empty())
{
Record res = Records.front();
cout<< "Processed: " << res.response << endl;
//some lengthy processing...., let's use sleep() to depict that
boost::this_thread::sleep(boost::posix_time::seconds(1));
Records.pop_front();
}
}
}
int main()
{
A a;
a.RunThreads();
}

Answer 1

You're adding futures in a tight loop:
void RunThread1() {
while(true)
{
// ...
auto f = std::async (std::launch::async, &A::PopulateResponses, this, responses);
pending_futures.push_back(std::move(f));
}
}
No wonder nothing can keep up with it. The other threads are doing all the locking (thread 1 has no blocking operations, though Is_future_ready might force a thread yield, I'm not sure).
Add a sleep somewhere in the loop and you'll find that things are working as expected.
boost::this_thread::sleep_for(boost::chrono::seconds(1));
Keep in mind that this is still brittle: it depends on timings to be correct. To be more generally robust, use a proper message/task queue and block the pushing side when the queue is full.