How can I implement callback functions in a QObject-derived class which are called from non-Qt multi-threaded libraries?

Question

(Pseudo-)Code

Here is a non-compilable code-sketch of the concepts I am having trouble with:

struct Data {};

struct A {};
struct B {};
struct C {};
/* and many many more...*/


template<typename T>
class Listener {
public:
  Listener(MyObject* worker):worker(worker)
  { /* do some magic to register with RTI DDS */ };

public:

  // This function is used ass a callback from RTI DDS, i.e. it will be
  // called from other threads when new Data is available
  void callBackFunction(Data d)
  {
  T t = extractFromData(d);

  // Option 1: direct function call 
  // works somewhat, but shows "QObject::startTimer: timers cannot be started 
  // from another thread" at the console...
  worker->doSomeWorkWithData(t); // 

  // Option 2: Use invokeMethod:
  // seems to fail, as the macro expands including '"T"' and that type isn't
  // registered with the QMetaType system...
//    QMetaObject::invokeMethod(worker,"doSomeGraphicsWork",Qt::AutoConnection,
//           Q_ARG(T, t)  
//         );

    // Option 3: use signals slots
    // fails as I can't make Listener, a template class, a QObject... 
//    emit workNeedsToBeDone(t);
  }

private:
  MyObject* worker;
  T extractFromData(Data d){ return T(d);};
};


class MyObject : public QObject {
Q_OBJECT

public Q_SLOTS:
  void doSomeWorkWithData(A a); // This one affects some QGraphicsItems.
  void doSomeWorkWithData(B b){};
  void doSomeWorkWithData(C c){};

public:
  MyObject():QObject(nullptr){};

  void init()
  {
  // listeners are not created in the constructor, but they should have the 
  // same thread affinity as the MyObject instance that creates them...
  // (which in this example--and in my actual code--would be the main GUI
  // thread...)
  new Listener<A>(this);
  new Listener<B>(this); 
  new Listener<C>(this); 
  };
};


main()
{
  QApplication app;

  /* plenty of stuff to set up RTI DDS and other things... */

  auto myObject = new MyObject();

  /* stuff resulting in the need to separate "construction" and "initialization" */

  myObject.init();


  return app.exec();

};

Some more details from the actual code:

The Listener in the example is a RTI DataReaderListener, the callback function is onDataAvailable()

What I would like to accomplish

I am trying to write a little distributed program that uses RTI's Connext DDS for communication and Qt5 for the GUI stuff--however, I don't believe those details do matter much as the problem, as far as I understood it, boils down to the following:

• I have a QObject-derived object myObject whose thread affinity might or might not be with the main GUI thread (but for simplicity, let's assume that is the case.)
• I want that object to react to event's which happen in another, non-Qt 3rd-party library (in my example code above represented by the functions doSomeWorkWithData().

What I understand so far as to why this is problematic

Disclaimer: As usual, there is always more than one new thing one learns when starting a new project. For me, the new things here are/were RTI's Connext and (apparently) my first time where I myself have to deal with threads.

From reading about threading in Qt (1,2,3,4, and 5 ) it seems to me that

• QObjects in general are not thread safe, i.e. I have to be a little careful about things
• Using the right way of "communicating" with QObjects should allow me to avoid having to deal with mutexes etc myself, i.e. somebody else (Qt?) can take care of serializing access for me.

As a result from that, I can't simply have (random) calls to MyClass::doSomeWorkWithData() but I need to serialize that. One, presumably easy, way to do so is to post an event to the event queue myObject lives in which--when time is available--will trigger the execution of the desired method, MyClass::doSomeWorkWithData() in my case.

What I have tried to make things work

I have confirmed that myObject, when instantiated similarly as in the sample code above, is affiliated with the main GUI thread, i.e. myObject.thread() == QApplication::instance()->thread().

With that given, I have tried three options so far:

Option 1: Directly calling the function

This approach is based upon the fact that - myObject lives in the GUI thread - All the created listeners are also affiliated with the GUI thread as they are created by `myObject' and inherit its thread that way

This actually results in the fact that doSomeWorkWithData() is executed. However, some of those functions manipulate QGraphicsItems and whenever that is the case I get error messages reading: "QObject::startTimer: timers cannot be started from another thread".

Option 2: Posting an event via QMetaObject::invokeMethod()

Trying to circumvent this problem by properly posting an event for myObject, I tried to mark MyObject::doSomeWorkWithData() with Q_INVOKABLE, but I failed at invoking the method as I need to pass arguments with Q_ARG. I properly registered and declared my custom types represented by struct A, etc. in the example), but I failed at the fact the Q_ARG expanded to include a literal of the type of the argument, which in the templated case didn't work ("T" isn't a registered or declared type).

Trying to use conventional signals and slots

This approach essentially directly failed at the fact that the QMeta system doesn't work with templates, i.e. it seems to me that there simply can't be any templated QObjects.

What I would like help with

After spending about a week on attempting to fix this, reading up on threads (and uncovering some other issues in my code), I would really like to get this done right. As such, I would really appreciate if :

1. somebody could show me a generic way of how a QObject's member function can be called via a callback function from another 3rd-party library (or anything else for that matter) from a different, non QThread-controlled, thread.

2. somebody could explain to me why Option 1 works if I simply don't create a GUI, i.e. do all the same work, just without a QGraphcisScene visualizing it (and the project's app being a QCoreApplication instead of a QApplication and all the graphics related work #defineed out).

Any, and I mean absolutely any, straw I could grasp on is truly appreciated.

Update

Based on the accepted answer I altered my code to deal with callbacks from other threads: I introduced a thread check at the beginning of my void doSomeWorkWithData() functions:

void doSomeWorkWithData(A a)
{
  if( QThread::currentThread() != this->thread() )
  {
    QMetaObject::invokeMethod( this,"doSomeWorkWithData"
                              ,Qt::QueuedConnection
                              ,Q_ARG(A, a) );
    return;
  }
  /* The actual work this function does would be below here... */
};

Some related thoughts:

• I was contemplating to introduce a QMutexLocker before the if statement, but decided against it: the only part of the function that is potentially used in parallel (anything above the return; in the if statement) is--as far as I understand--thread safe.

• Setting the connection type manually to Qt::QueuedConnection: technically, if I understand the documentation correctly, Qt should do the right thing and the default, Qt::AutoConnection, should end up becoming a Qt::QueuedConnection. But since would always be the case when that statement is reached, I decided to put explicitly in there to remind myself about why this is there.

• putting the queuing code directly in the function and not hiding it in an interim function: I could have opted to put the call to invokeMethod in another interim function, say queueDoSomeWorkWithData()', which would be called by the callback in the listener and then usesinvokeMethodwith anQt::AutoConnection' on doSomeWorkWithData(). I decided against this as there seems no way for me to auto-code this interim function via templates (templates and the Meta system was part of the original problem), so "the user" of my code (i.e. the person who implements doSomeWorkWithData(XYZ xyz)) would have to hand type the interim function as well (as that is how the templated type names are correctly resolved). Including the check in the actual function seems to me to safe typing an extra function header, keeps the MyClass interface a little cleaner, and better reminds readers of doSomeWorkWithData() that there might be a threading issue lurking in the dark.

Answer 1

It is ok to call a public function on a subclass of QObject from another thread if you know for certain that the individual function will perform only thread-safe actions.

One nice thing about Qt is that it will handle foreign threads just as well as it handles QThreads. So, one option is to create a threadSafeDoSomeWorkWithData function for each doSomeWorkWithData that does nothing but QMetaMethod::invoke the non-threadsafe one.

public:
  void threadSafeDoSomeWorkWithData(A a) { 
    QMetaMethod::invoke("doSomeWorkWithData", Q_ARG(A,a)); 
  } 
  Q_INVOKABLE void doSomeWorkWithData(A a);

Alternatively, Sergey Tachenov suggests an interesting way of doing more or less the same thing in his answer here. He combines the two functions I suggested into one.

void Obj2::ping() {
    if (QThread::currentThread() != this->thread()) {
        // not sure how efficient it is
        QMetaObject::invoke(this, "ping", Qt::QueuedConnection);
        return;
    }
    // thread unsafe code goes here
}

As to why you see normal behaviour when not creating a GUI? Perhaps you're not doing anything else that is unsafe, aside from manipulating GUI objects. Or, perhaps they're the only place in which your thread-safety problems are obvious.