Qt blocked event loop

Question

I recently started using the QT framework. Yesterday I began programming a simple multithreaded application. At the moment I'm somewhat stuck on the following problem.

Consider two worker classes that both use a thread to do some 'heavy computations'. The first class, FooWorker, looks like the following:

class FooWorker : public QObject
{
    Q_OBJECT

public:
    FooWorker() : QObject() { }
    ~FooWorker() { }

signals:
    void notify(int);
    void aborted();

public slots:
    void doWork()
    {
        int counter = 0;
        forever {

            // For the sake of this example this reassembles a heavy computational process
            if(counter++ < 10) {
                emit notify(counter);
                QThread::sleep(1);
            } else {
                counter = 0;

                // Wait until we get a signal to restart the process
                mutex_.lock();
                condition_.wait(&mutex_);
                mutex_.unlock();
            }
            // We should check for a cancellation flag every iteration...
        }

        emit aborted();
    }

private:
    QMutex mutex_;
    QWaitCondition condition_;
};

The slot 'doWork' will be scheduled to run in another thread. The slot will run forever and is emitting a signal every second until 10 notifications are emitted. After that we wait until it is woken up again.

The second class, BarWorker, looks like this:

class BarWorker : public QObject
{
    Q_OBJECT

public:
    BarWorker() : QObject() { }
    ~BarWorker() { }

signals:
    void aborted();

public slots:
    void doWork()
    {
        forever {
            // Another heavy computational process
            QThread::sleep(1);

            // We should check for a cancellation flag every iteration...
        }

        emit aborted();
    }

    void onNotify(int value)
    {
        qDebug() << "Notification value:" << value;
    }
};

Again the slot 'doWork' will be scheduled to run in another thread. The slot will run forever to do a heavy computational process. Again once the process is done we will wait until it is woken up again (for the sake of this example I left that out in this class).

Finally the main looks like the following:

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QThread* barThread = new QThread();
    BarWorker* barWorker = new BarWorker();
    barWorker->moveToThread(barThread);

    QThread* fooThread = new QThread();
    FooWorker* fooWorker = new FooWorker();
    fooWorker->moveToThread(fooThread);

    // Automatically deletes worker and thread
    QObject::connect(fooThread, SIGNAL(started()), fooWorker, SLOT(doWork()));
    QObject::connect(fooWorker, SIGNAL(aborted()), fooThread, SLOT(quit()));
    QObject::connect(fooWorker, SIGNAL(aborted()), fooWorker, SLOT(deleteLater()));
    QObject::connect(fooThread, SIGNAL(finished()), fooThread, SLOT(deleteLater()));

    QObject::connect(barThread, SIGNAL(started()), barWorker, SLOT(doWork()));
    QObject::connect(barWorker, SIGNAL(aborted()), barThread, SLOT(quit()));
    QObject::connect(barWorker, SIGNAL(aborted()), barWorker, SLOT(deleteLater()));
    QObject::connect(barThread, SIGNAL(finished()), barThread, SLOT(deleteLater()));

    QObject::connect(fooWorker, SIGNAL(notify(int)), barWorker, SLOT(onNotify(int)), Qt::QueuedConnection);

    fooThread->start();
    barThread->start();

    return a.exec();
}

When I run the application nothing gets printed. That was to be expected because the event loop of the BarWorker instance is blocked. As the 'notify' signal gets emitted the 'onNotify' slot is queued onto the event queue. Because we have a never ending loop (until we manually abort it) in the 'doWork' slot, the 'onNotify' slot will not be called. To solve this I can do a couple of things, namely:

1. Connect the 'notify' signal to the 'onNotify' slot by using the Qt::DirectConnection flag. This way it looks like a normal function call executing on the signalling thread.
2. Occasionally call the QCoreApplication::processEvents() method to force the event queue to be processed.
3. Unknown solution I do not know at this time :)???

I hope someone has some alternative solution to this problem, or even suggest an entire different approach, because IMHO above solutions are somewhat ugly and do not feel right.

Answer 1

I don't think there is any "magic" solution to be found here; a thread can't be running Qt's event loop if it is running your own custom event loop. In practice, there are two common solutions, which are really two sides of the same coin:

1. Call processEvents() periodically from your event loop, as you suggested in your question, so that the Qt event-handling code occasionally gets to run and handle incoming asynchronous signals.

2. Don't have a long-running loop in your doWork() method. Instead, do a short amount of work, store the results/state of that work in a member variable or somewhere, and then call something like QTimer::singleShot(0, this, SLOT(doWork())) so that the Qt event loop will call your doWork() method again soon after the first call to doWork() returns. That way the Qt event loop never gets held off for longer than the (brief) period of time taken up by a single doWork() call.

Of those two options, I think the second is preferable, because it allows the Qt event loop to run in its normal fashion, and it also avoids a potential tripping-over-your-own-shoelaces issue -- e.g. imagine if while using solution (1) your call to processEvents() causes a slot to be called that deletes the BarWorker object. When the processEvents() call returns, BarWorker::doWork() will resume executing, but at that point, all of the local member variables and virtual methods it might access as part of its normal execution have been destroyed, and reading or writing them will cause undefined behavior (if you're lucky, an easy-to-debug crash). That possible snafu can't happen when using solution (2), since if the BarWorker object gets deleted between calls to doWork(), any queued-up asynchronous call to doWork() will be safely cancelled.

Answer 2

The idiom for a forever loop that interoperates with the event loop is a zero-duration timer. We can factor it out into a WorkerBase class, where the unit of work is to be done in the workUnit method:

// https://github.com/KubaO/stackoverflown/tree/master/questions/worker-timer-40369716
#include <QtCore>

// See http://stackoverflow.com/q/40382820/1329652
template <typename Fun> void safe(QObject * obj, Fun && fun) {
    Q_ASSERT(obj->thread() || qApp && qApp->thread() == QThread::currentThread());
    if (Q_LIKELY(obj->thread() == QThread::currentThread()))
        return fun();
    struct Event : public QEvent {
      using F = typename std::decay<Fun>::type;
      F fun;
      Event(F && fun) : QEvent(QEvent::None), fun(std::move(fun)) {}
      Event(const F & fun) : QEvent(QEvent::None), fun(fun) {}
      ~Event() { fun(); }
    };
    QCoreApplication::postEvent(
          obj->thread() ? obj : qApp, new Event(std::forward<Fun>(fun)));
}

class WorkerBase : public QObject {
    Q_OBJECT
    QBasicTimer timer_;
protected:
    virtual void workUnit() = 0;
    void timerEvent(QTimerEvent *event) override {
        if (event->timerId() == timer_.timerId() && timer_.isActive())
            workUnit();
    }
public:
    using QObject::QObject;
    Q_SIGNAL void finished();
    /// Thread-safe
    Q_SLOT void virtual start() {
        safe(this, [=]{
           timer_.start(0, this);
        });
    }
    /// Thread-safe
    Q_SLOT void virtual stop() {
        safe(this, [=]{
            if (!isActive()) return;
            timer_.stop();
            emit finished();
        });
    }
    bool isActive() const { return timer_.isActive(); }
    ~WorkerBase() {
        if (isActive()) emit finished();
    }
};

The workers then become:

class FooWorker : public WorkerBase
{
    Q_OBJECT
    int counter = 0;
    bool isDone() const { return counter >= 10; }
    void workUnit() override {
        if (!isDone()) {
            counter ++;
            emit notify(counter);
            QThread::sleep(1);
        } else
            stop();
    }
public:
    void start() override {
        counter = 0;
        WorkerBase::start();
    }
    void stop() override {
        if (!isDone()) emit aborted();
        WorkerBase::stop();
    }
    Q_SIGNAL void notify(int);
    Q_SIGNAL void aborted();
};

class BarWorker : public WorkerBase
{
    Q_OBJECT
    void workUnit() override {
        QThread::sleep(1);
    }
public:
    void stop() override {
        emit aborted();
        WorkerBase::stop();
    }
    Q_SIGNAL void aborted();
    Q_SLOT void onNotify(int value)
    {
        qDebug() << "Notification value:" << value;
    }
};

Note that the aborted() and finished() signals have different meanings.

Finally, the test harness:

class Thread : public QThread { public: ~Thread() { quit(); wait(); } };

int main(int argc, char ** argv) {
    QCoreApplication app{argc, argv};

    BarWorker barWorker;
    FooWorker fooWorker;
    Thread barThread, fooThread;
    barWorker.moveToThread(&barThread);
    fooWorker.moveToThread(&fooThread);
    barWorker.start();
    fooWorker.start();

    QObject::connect(&fooWorker, &FooWorker::finished, &app, &QCoreApplication::quit);
    QObject::connect(&fooWorker, &FooWorker::notify, &barWorker, &BarWorker::onNotify);

    fooThread.start();
    barThread.start();
    return app.exec();
}

#include "main.moc"

If you get a QBasicTimer::stop: Failed. Possibly trying to stop from a different thread warning, it's of no consequence and is a result of a Qt bug.