[Solved] How do I create a pause/wait function using Qt?

I’m playing around with Qt, and I want to create a simple pause between two commands. However it won’t seem to let me use Sleep(int mili);, and I can’t find any obvious wait functions.

I am basically just making a console application to test some class code which will later be included in a proper Qt GUI, so for now I’m not bothered about breaking the whole event-driven model.

Enquirer: Zac


Solution #1:

This previous question mentions using qSleep() which is in the QtTest module. To avoid the overhead linking in the QtTest module, looking at the source for that function you could just make your own copy and call it. It uses defines to call either Windows Sleep() or Linux nanosleep().

#ifdef Q_OS_WIN
#include <windows.h> // for Sleep
void QTest::qSleep(int ms)
    QTEST_ASSERT(ms > 0);

#ifdef Q_OS_WIN
    struct timespec ts = { ms / 1000, (ms % 1000) * 1000 * 1000 };
    nanosleep(&ts, NULL);
Respondent: Arnold Spence

Solution #2:

I wrote a super simple delay function for an application I developed in Qt.

I would advise you to use this code rather than the sleep function as it won’t let your GUI freeze.

Here is the code:

void delay()
    QTime dieTime= QTime::currentTime().addSecs(1);
    while (QTime::currentTime() < dieTime)
        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);

To delay an event by n seconds – use addSecs(n).

Respondent: Kartik Sharma

Solution #3:

From Qt5 onwards we can also use

Static Public Members of QThread

void    msleep(unsigned long msecs)
void    sleep(unsigned long secs)
void    usleep(unsigned long usecs)
Respondent: Yash

Solution #4:

Small +1 to kshark27‘s answer to make it dynamic:

#include <QTime>

void delay( int millisecondsToWait )
    QTime dieTime = QTime::currentTime().addMSecs( millisecondsToWait );
    while( QTime::currentTime() < dieTime )
        QCoreApplication::processEvents( QEventLoop::AllEvents, 100 );
Respondent: GraehamF

Solution #5:

I’ve had a lot of trouble over the years trying to get QApplication::processEvents to work, as is used in some of the top answers. IIRC, if multiple locations end up calling it, it can end up causing some signals to not get processed ( My usual preferred option is to utilize a QEventLoop (

inline void delay(int millisecondsWait)
    QEventLoop loop;
    QTimer t;
    t.connect(&t, &QTimer::timeout, &loop, &QEventLoop::quit);
Respondent: dvntehn00bz

Solution #6:

We’ve been using the below class –

class SleepSimulator{
     QMutex localMutex;
     QWaitCondition sleepSimulator;
    void sleep(unsigned long sleepMS)
        sleepSimulator.wait(&localMutex, sleepMS);
    void CancelSleep()

QWaitCondition is designed to coordinate mutex waiting between different threads. But what makes this work is the wait method has a timeout on it. When called this way, it functions exactly like a sleep function, but it uses Qt’s event loop for the timing. So, no other events or the UI are blocked like normal windows sleep function does.

As a bonus, we added the CancelSleep function to allows another part of the program to cancel the “sleep” function.

What we liked about this is that it lightweight, reusable and is completely self contained.



Respondent: photo_tom

Solution #7:

Since you’re trying to “test some class code,” I’d really recommend learning to use QTestLib. It provides a QTest namespace and a QtTest module that contain a number of useful functions and objects, including QSignalSpy that you can use to verify that certain signals are emitted.

Since you will eventually be integrating with a full GUI, using QTestLib and testing without sleeping or waiting will give you a more accurate test — one that better represents the true usage patterns. But, should you choose not to go that route, you could use QTestLib::qSleep to do what you’ve requested.

Since you just need a pause between starting your pump and shutting it down, you could easily use a single shot timer:

class PumpTest: public QObject {
    Pump &pump;
    PumpTest(Pump &pump):pump(pump) {};
public slots:
    void start() { pump.startpump(); }
    void stop() { pump.stoppump(); }
    void stopAndShutdown() {
    void test() {
        QTimer::singleShot(1000, this, SLOT(stopAndShutdown));

int main(int argc, char* argv[]) {
    QCoreApplication app(argc, argv);
    Pump p;
    PumpTest t(p);
    return app.exec();

But qSleep() would definitely be easier if all you’re interested in is verifying a couple of things on the command line.

EDIT: Based on the comment, here’s the required usage patterns.

First, you need to edit your .pro file to include qtestlib:

CONFIG += qtestlib

Second, you need to include the necessary files:

  • For the QTest namespace (which includes qSleep): #include <QTest>
  • For all the items in the QtTest module: #include <QtTest>. This is functionally equivalent to adding an include for each item that exists within the namespace.
Respondent: Kaleb Pederson

Solution #8:

To use the standard sleep function add the following in your .cpp file:

#include <unistd.h>

As of Qt version 4.8, the following sleep functions are available:

void QThread::msleep(unsigned long msecs)
void QThread::sleep(unsigned long secs)
void QThread::usleep(unsigned long usecs)

To use them, simply add the following in your .cpp file:

#include <QThread>

Reference: QThread (via Qt documentation):

Otherwise, perform these steps…

Modify the project file as follows:

CONFIG += qtestlib

Note that in newer versions of Qt you will get the following error:

Project WARNING: CONFIG+=qtestlib is deprecated. Use QT+=testlib instead.

… so, instead modify the project file as follows:

QT += testlib

Then, in your .cpp file, be sure to add the following:

#include <QtTest>

And then use one of the sleep functions like so:


Solution #9:

@kshark27‘s answer didn’t work for me for some reason (because I use Qt 5.7?) so I ended up doing this:

while (someCondition) {

   // do something

   QThread::sleep(1); // 1 second


If this is done in the GUI thread, it obviously introduces a 1 second GUI lag before responding to user events. But if you can live with it, this solution is probably an easiest to implement and even Qt endorses it in their Threading Basics article (see When to Use Alternatives to Threads section).

Respondent: Neurotransmitter

Solution #10:

we can use following method QT_Delay:


This will wait for 2 seconds before calling print_lcd().

Respondent: user11514364

Solution #11:

Similar to some answers here, but maybe a little more lightweight

void MyClass::sleepFor(qint64 milliseconds){
    qint64 timeToExitFunction = QDateTime::currentMSecsSinceEpoch()+milliseconds;
        QApplication::processEvents(QEventLoop::AllEvents, 100);
Respondent: hytromo

Solution #12:

If you want a cross-platform method of doing this, the general pattern is to derive from QThread and create a function (static, if you’d like) in your derived class that will call one of the sleep functions in QThread.

Respondent: San Jacinto

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Most Popular

To Top
India and Pakistan’s steroid-soaked rhetoric over Kashmir will come back to haunt them both clenbuterol australia bossier man pleads guilty for leadership role in anabolic steriod distribution conspiracy