发出 Qt 信号的线程安全

Question

I'm using QtConcurrent::run (I know other APIs of QtConcurrent has built in support for progress reporting but I can't use them for other reasons). to run an operation inside a different than the main GUI thread. I also need this operation to notify the GUI thread of the progress made. So what I did is that created a separate function for the operation I want which accepts a callback that carries the information about the progress of the operation. This callback then calls the signal on a QObject living in the main thread.

Here is a full working example that shows my structure:

    #include <QCoreApplication>
    #include <QObject>
    #include <QThread>
    #include <QtConcurrent/QtConcurrent>
    
    
    namespace Operations {
    
    template<typename Callback>
    void longOperation(Callback progressCallback)
    {
        qint64 sum = 0;
        for(int i = 0; i < 100; ++i){
            QThread::msleep(400);
            sum += i;
            progressCallback(i/100.0);
        }
    }
    
    }

    class Emitter : public QObject
    {
        Q_OBJECT
    public:
        Q_INVOKABLE void doSomething()
        {
            auto progressCallback = [&](qreal p){
                emit progress(p);
            };
    
            auto lambda = [progressCallback](){
                Operations::longOperation(progressCallback);
            };
    
            QtConcurrent::run(lambda);
        }
    signals:
        void progress(qreal);
    };
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        Emitter emitter;
        QObject::connect(&emitter, &Emitter::progress, [](qreal progress){
            qDebug() << "Progress" << progress;
        });
        emitter.doSomething();
    
        return a.exec();
    }
    
    
    #include "main.moc"

Now my question is using the progressCallback as defined above thread safe? The callback will clearly be triggered from a thread different than the GUI thread, so effectively it's calling emitter.progress() directly on the QObject.

Answer 1

Ok, so I now realised that the code above may not be thread safe. Part of my confusion was what does the emit keyword actually does. It turns out it's actually not much at all. So calling the signal from another thread is not really the best idea. Instead, one of way of improve the situation is replace the progressCallback with:

        auto progressCallback = [&](qreal p){
            QMetaObject::invokeMethod(this, [this, p](){ emit progress(p);}, Qt::QueuedConnection);
        };

This way the signal is emitted on the thread where the Emitter lives as the lambda slot will be executed "when control returns to the event loop of the receiver's thread" as per the Qt documentation.