sigslot signals across threads - c++

Question

I'm using sigslot library to trigger signals in a function. This function runs in a thread using QtConcurrent::run, and signals are connected in the main thread.
It's quite working as expected, except that the signal connection doesn't work every time (let's say around 25% failure).
This erratic behavior is problematic and I can't find a solution. Signals in sigslot library have different options depending on the multithreading context, but none of them is fixing the problem.
Before trying boost, I really would like to find a solution to keep using sigslot since it's a quite simple library and I only need a basic use of signals and slots in this part of the code. And I don't want to use Qt for this because I prefer to leave this same part of the code free of Qt.
Any hint would be much appreciated.
Update : for some reason, using as a desperate try sigslot::single_threaded appears to give way better results.
signal1<int, single_threaded> Sig1;
I'm not saying it's solving the problem since it doesn't make sense to me. As explained in the documentation :
Single Threaded In single-threaded mode, the library does not attempt to protect its internal data structures
across threads. It is therefore essential that all calls to constructors, destructors and signals
must exist within a single thread.
Update 2 :
Here is a MWE. But results are quite random. Sometimes it fully works, sometimes not all. I know it sounds weird, but that's the problem. I also tried boost::signals2 instead of sigslot, but result is quite the same. There's a executable bad access in boost::signals2::mutex::lock()
class A {
public :
A() {}
~A() {}
sigslot::signal1<int, sigslot::multi_threaded_local> sigslot_signal;
boost::signals2::signal<void (int)> boost_signal;
void func_sigslot() {
for (int i=0;i<4;i++) {
sigslot_signal.emit_signal(i);
}
}
void func_boost() {
for (int i=0;i<4;i++) {
boost_signal(i);
}
}
};
class B : public sigslot::has_slots<sigslot::multi_threaded_local> {
public :
B() {}
~B() {}
void test(int i) {
std::cout << "signal triggered, i=" << i << std::endl;
}
};
void main() {
A a;
B b;
a.sigslot_signal.connect_slot(&b, &B::test);
a.boost_signal.connect(boost::bind(&B::test, &b, _1));
QtConcurrent::run(&a, &A::func_sigslot);//->crashes when signal emitted
QtConcurrent::run(&a, &A::func_boost);//->crashes when signal emitted
boost::thread t1(boost::bind(&A::func, &a));
t1.join();//works fine
}

Answer 1

The Sarah Thompson's sigslot library (if that's what you use) is old, unsupported, and seems quite buggy. There's no test harness of any sort. The original source doesn't compile under modern compilers. There are typos there that were hidden due to MSVC's former treatment of templates as token lists: obviously parts of the code were never used!
I highly suggest that you simply use Qt, or a different signal-slot library.
Alas, your approach can't work: the sigslot library has no idea about Qt's thread contexts, and doesn't integrate with Qt's event loop. The slots are called from the wrong thread context. Since you likely didn't write your slots to be thread-safe, they don't do the right thing and appear not to work.
The sigslot library's threading support only protects the library's own data, not your data. Setting the multithreading policies only affects the library's data. This is in stark contrast with Qt, where each QObject's thread context is known and enables the signal-slot system to act safely.
In order to get it to work, you need to expose a thread-safe interface in all the QObject's whose slots you're invoking. This can be as simple as:
class Class : public QObject {
Q_OBJECT
public:
Class() {
// This could be automated via QMetaObject and connect overload
// taking QMetaMethod
connect(this, &Class::t_slot, this, &Class::slot);
}
Q_SIGNAL void t_slot();
Q_SLOT slot() { ... }
}
Instead of connecting to slot(), connect to t_slot(), where the t_ prefix stands for threadsafe/thunk.