Inter thread communication in C++ [closed] - c++

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 5 years ago.
Improve this question
From the main of my program I am launching to threads (A and B). Thread_A is in charge of generating blocks of a signal (it stores theses blocks in a matrix visible for both threads), whereas Thread_B is responsible for its transmission.
My goal is that each time thread_A generates a block, it has to notify thread_B for its transmission (maybe a good approach would be to send the address of the memmory blocks filled). For this purpose, I thougth to use POSIX message queues, but unfortunately I have no experience with this kind of stuff.
Can anybody provide me a simple example of inter thread communication applicable for this scenario?

Answer 1

Here some example with using condition variable. One thread generates signals. The other one transmits them. The signals in this example are just int's. There is also a sleep there to simulate some load. Hope this helps:
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <future>
#include <thread>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <utility>
#include <chrono>
using namespace std;
bool rdy_flg;
mutex rdy_mtx;
condition_variable rdy_cond_var;
bool finished;
vector<int> my_signals;
void GenerateSignals() {
const int kNumOfTests = 10;
for (int i = 0; i < kNumOfTests; ++i) {
// 1. for each test generate some random signals - just int's in this case
int n = rand() % 11;
if (n == 0) n = 5;
vector<int> vec(n);
for (int j = 0; j < n; ++j) vec[j] = rand() % 1000;
{
// 2. now we are updating the global variable
// -> need to lock here
lock_guard<mutex> lg(rdy_mtx);
my_signals = vec;
cout << "Generating signals: ";
for (auto& v : my_signals) cout << v << " ";
cout << endl;
rdy_flg = true;
// if last test -> set finished to true for other thread
// to know to not wait for new notifications any more
if (i == kNumOfTests-1)
finished = true;
} // 3. lock guard goes out of scope -> automatic unlock
// 4. send notification to the other thread
rdy_cond_var.notify_one();
// 5. simulate some heavy work
this_thread::sleep_for(chrono::seconds(1));
}
}
void TransmitSignals() {
while (!finished) {
// need unique lock here
unique_lock<mutex> ul(rdy_mtx);
// wait for notification until rdy_flg is true - there is something to read
rdy_cond_var.wait(ul, [] { return rdy_flg; });
cout << "Transmitting signals: ";
for (auto& v : my_signals) cout << v << " ";
cout << endl;
// reset rdy_flg to false for not to process the same signals again
rdy_flg = false;
}
}
int main() {
srand(time(nullptr));
auto f1 = async(launch::async, GenerateSignals);
auto f2 = async(launch::async, TransmitSignals);
}
Here the live example: https://wandbox.org/permlink/hgoZB8POiWAYEZ5I
Here the updating example with processing the same signal repeatly :
#include <cstdlib>
#include <ctime>
#include <chrono>
#include <condition_variable>
#include <future>
#include <iostream>
#include <memory>
#include <mutex>
#include <thread>
#include <utility>
#include <vector>
using namespace std;
mutex mtx_signals;
mutex mtx_cout;
bool finished;
vector<int> my_signals;
void GenerateSignals() {
const int kNumOfTests = 3;
for (int i = 0; i <= kNumOfTests; ++i) {
int n = rand() % 11;
if (n == 0) n = 5;
vector<int> vec(n);
for (int j = 0; j < n; ++j) vec[j] = rand() % 1000;
if (!finished) {
{
lock_guard<mutex> lg(mtx_signals);
my_signals = vec;
if (i >= kNumOfTests) finished = true;
}
if (!finished) {
lock_guard<mutex> lgcout(mtx_cout);
cout << "Generating signals: ";
for (auto& v : my_signals) cout << v << " ";
cout << endl;
}
}
this_thread::sleep_for(chrono::seconds(1));
}
}
void TransmitSignals() {
while (!finished) {
vector<int> sigs;
{
lock_guard<mutex> lg(mtx_signals);
sigs = my_signals;
}
if (sigs.size()) {
lock_guard<mutex> lgcout(mtx_cout);
cout << "Transmitting signals: ";
for (auto& v : sigs) cout << v << " ";
cout << endl;
}
this_thread::sleep_for(chrono::milliseconds(200));
}
}
int main() {
srand(time(nullptr));
auto f1 = async(launch::async, GenerateSignals);
auto f2 = async(launch::async, TransmitSignals);
}
https://wandbox.org/permlink/R7DdsdItqJX0L07k