Pointing to thread object from another object: dangerous? - c++

Question

Suppose there are two objects both inherit from a thread parent class "utility thread that uses pthreads".
class Othread1: public thread
{
public:
start() { /* launch thread at 10 Hz */ };
end();
void setvar(float vr) {var2= vr } ;
protected :
float var1;
}
and
class Othread2: public thread
{
start() { /* launch the thread at 1000 Hz */ } ;
end();
float getvar() { return var2 } ;
protected :
float var2;
}
Is there a such thing where we can do this?
void threadManager(thread *th1, thread *th2)
{
float vtemp = th2->getvar();
th1->setvar(vtemp);
}
int main ()
{
thread th1;
thread th2;
threadManager(&th1,&th2);
return 0;
}
Is such interthread data use a safe thing to do? Or do I have to do queues with producer/consumer pattern to exchange the data?

Answer 1

I'm still not entirely sure what you are trying to do but here is an example that will hopefully help you.
If you want to read data in one thread that is concurrently written in another thread you need synchronization or you'll invoke undefined behavior. Whether there is much or little time between the “writing event” and the “reading event” is not important. As far as the language rules are concerned, everything that happens between two synchronization points is “simultaneous”.
The definitive rules for this can be found in § 1.10 [intro.multithreaded] of N4140, the final draft for the C++14 standard. But the language used there can be hard to decipher.
A more informal explanation can be found in § 41.2.4 of The C++ Programming Language (4th edition) by Bjarne Stroustrup.
Two threads have a data race if both can access a memory location simultaneously and at least one of their accesses is a write. Note that defining “simultaneously” precisely is not trivial. If two threads have a data race, no language guarantees hold: the behavior is undefined.
As far as I am concerned, I think that the “can” in the first sentence is bogus and should not be there but I'm quoting the book as-is.
The classic way of protecting mutual access is using mutices and locks. Since C++11 (and only since C++11, C++ has a definition of concurrency at all), the standard library provides std::mutex and std::lock_guard (both defined in the <mutex> header) for this purpose.
If you have simple types like integers, using locks is overkill, however. Modern hardware supports atomic operations on such simple types. The standard library provides the std::atomic class template for this (defined in the <atomic> header). You can use it on any trivially copyable types.
Here is a rather useless example where we have two threads that execute a function writer and reader respectively. The writer has a pseudo-random number generator and periodically asks it to produce a new random integer that it stores atomically in the global variable value. The reader periodically loads the value of value atomically and advances its own pseudo-random number generator until it catches up. A second global atomic variable done is used by the main thread to signal to the two threads when they should stop. Note that I have replaced your hertz with kilohertz so it is less boring to wait for the program to execute.
#include <atomic>
#include <chrono>
#include <random>
#include <thread>
namespace /* anonymous */
{
std::atomic<bool> done {};
std::atomic<int> value {};
void
writer(const std::chrono::microseconds period)
{
auto rndeng = std::default_random_engine {};
auto rnddst = std::uniform_int_distribution<int> {};
while (!done.load())
{
const auto next = rnddst(rndeng);
value.store(next);
std::this_thread::sleep_for(period);
}
}
void
reader(const std::chrono::microseconds period)
{
auto rndeng = std::default_random_engine {};
auto rnddst = std::uniform_int_distribution<int> {};
auto last = 0;
while (!done.load())
{
const auto next = value.load();
while (last != next)
last = rnddst(rndeng);
std::this_thread::sleep_for(period);
}
}
}
int
main()
{
using namespace std::chrono_literals;
std::thread writer_thread {writer, 100us}; // 10 kHz
std::thread reader_thread {reader, 10us}; // 100 kHz
std::this_thread::sleep_for(3s);
done.store(true);
writer_thread.join();
reader_thread.join();
}
If you have a modern GCC or Clang, you can (and probably should) compile your debug builds with the -fsanitize=thread switch. If you run a thusly compiled binary and it executes a data race, the special instrumentations added by the compiler will output a helpful error message. Try replacing the std::atomic<int> value in the above program with an ordinary int value and see what the tool will report.
If you don't have C++14 yet, you cannot use the literal suffixes but have to spell out std::chrono::microseconds {10} and so forth.