How could one delay a function without the use of sleep / suspending the code?

Question

I need to delay a function by x amount of time. The problem is that I can't use sleep nor any function that suspends the function (that's because the function is a loop that contains more function, sleeping / suspending one will sleep / suspend all)

Is there a way I could do it?

what is your goal exactly? You want to sleep but dont want to sleep?? — Raildex, Feb 24 '22 at 08:09
Start it in a new thread so that it can sleep without affecting the other functions. — Mark Setchell, Feb 24 '22 at 08:10
Please give more context. The answer depends on the context. — JHBonarius, Feb 24 '22 at 08:18
async(launch::async, []{ sleep_for(10ms); doSomething(); }); — Sebastian, Feb 24 '22 at 08:50
do you use some framework or other complex library with event loop? — Marek R, Feb 24 '22 at 09:35

score 2 · Accepted Answer · answered Feb 24 '22 at 08:41

If you want to execute some specific code at a certain time interval and don't want to use threads (to be able to suspend), then you have to keep track of time and execute the specific code when the delay time was exceeded.

Example (pseudo):

timestamp = getTime();

while (true) {

    if (getTime() - timestamp > delay) {

        //main functionality

        //reset timer
        timestamp = getTime();

    }

    //the other functionality you mentioned

}

With this approach, you invoke a specific fuction every time interval specified by delay. The other functions will be invoked at each iteration of the loop.

In other words, it makes no difference if you delay a function or execute it at specific time intervals.

score 1 · Answer 2 · answered Feb 24 '22 at 09:16

Assuming that you need to run functions with their own arguments inside of a loop with custom delay and wait for them to finish before each iteration:

#include <cstdio>

void func_to_be_delayed(const int &idx = -1, const unsigned &ms = 0)
{
    printf("Delayed response[%d] by %d ms!\n", idx, ms);
}

#include <chrono>
#include <future>

template<typename T, typename ... Ta>
void delay(const unsigned &ms_delay, T &func, Ta ... args)
{
    std::chrono::time_point<std::chrono::high_resolution_clock> start = std::chrono::high_resolution_clock::now();
    double elapsed;
    do {
        std::chrono::time_point<std::chrono::high_resolution_clock> end = std::chrono::high_resolution_clock::now();
        elapsed = std::chrono::duration<double, std::milli>(end - start).count();
    } while(elapsed <= ms_delay);
    func(args...);
}

int main()
{
    func_to_be_delayed();
    const short iterations = 5;
    for (int i = iterations; i >= 0; --i)
    {
        auto i0 = std::async(std::launch::async, [i]{ delay((i+1)*1000, func_to_be_delayed, i, (i+1)*1000); } );
        // Will arrive with difference from previous
        auto i1 = std::async(std::launch::async, [i]{ delay(i*1000, func_to_be_delayed, i, i*1000); } );
        func_to_be_delayed();
        // Loop will wait for all calls
    }
}

Notice: this method potentially will spawn additional thread on each call with std::launch::async type of policy.

Perhaps `std::async(std::launch::async, [i]{ delay(` for each delayed call could also be combined into a function. — Sebastian, Feb 24 '22 at 09:49

Marek R · Answer 3 · 2022-02-24T10:43:28.147

Standard solution is to implement event loop. If you use some library, framework, system API, then most probably there is something similar provided to solve this kind of problem.

For example Qt has QApplication which provides this loop and there is QTimer. boost::asio has io_context which provides even loop in which timer can be run boost::asio::deadline_timer.

You can also try implement such event loop yourself.

Example wiht boost:

#include <boost/asio.hpp>
#include <boost/date_time.hpp>
#include <exception>
#include <iostream>

void printTime(const std::string& label)
{
    auto timeLocal = boost::posix_time::second_clock::local_time();
    boost::posix_time::time_duration durObj = timeLocal.time_of_day();
    std::cout << label <<  " time = " << durObj << '\n';
}

int main() {
    boost::asio::io_context io_context;

    try {
        boost::asio::deadline_timer timer{io_context};
        timer.expires_from_now(boost::posix_time::seconds(5));

        timer.async_wait([](const boost::system::error_code& error){
            if (!error) {
                printTime("boom");
            } else {
                std::cerr << "Error: " << error << '\n';
            }
        });

        printTime("start");
        io_context.run();
    } catch (const std::exception& e) {
        std::cerr << e.what() << '\n';
    }
    return 0;
}

https://godbolt.org/z/nEbTvMhca

C++20 introduces coroutines, this could be a good solution too.

How could one delay a function without the use of sleep / suspending the code?

3 Answers3