How to safely use boost deadline timer in multiple threads?

Question

I use boost deadline_timer like this code:

boost::asio::io_service g_io;
#define DEL(x) {delete x; x = NULL;}

void thr1()
{
    for(;;)
    {

         ...
        boost::asio::deadline_timer *t1 = new boost::asio::deadline_timer(g_io, boost::posix_time::seconds(60));
        t1->async_wait(boost::bind(&callback, boost::asio::placeholders::error, t1));

         ...
    }
}


void thr2()
{
    for(;;)
    {
           ....


        boost::asio::deadline_timer *t2 = new boost::asio::deadline_timer(g_io, boost::posix_time::seconds(60));
        t2->async_wait(boost::bind(&callback, boost::asio::placeholders::error, t2));

            ....
    }
}


void thr3()
{
    for(;;)
    {

         ....

        boost::asio::deadline_timer *t3 = new boost::asio::deadline_timer(g_io, boost::posix_time::seconds(60));
        t3->async_wait(boost::bind(&callback, boost::asio::placeholders::error, t3));

         ....
    }
}


void thr4()
{
    for(;;)
    {
         ....

        boost::asio::deadline_timer *t4 = new boost::asio::deadline_timer(g_io, boost::posix_time::seconds(60));
        t4->async_wait(boost::bind(&callback, boost::asio::placeholders::error, t4));

        ....
    }
}

void io_work()
{
    boost::asio::io_service::work work(g_io);
    g_io.run();
}


int main()
{
    boost::thread thread1(thr1);
    boost::thread thread2(thr2);
    boost::thread thread3(thr3);
    boost::thread thread4(thr4);

    boost::thread service_thread(io_work);

    thread1.join();
    thread2.join();
    thread3.join();
    thread4.join();

    service_thread.join();

    return 0;

}


void callback(const boost::system::error_code& e, boost::asio::deadline_timer *timer)
{
    if(e)
    {
        std::cout << "cancel" << std::endl;
    }
    else
    {
        std::cout << " time out occurred" << std::endl;

        if(timer->expires_at() <= boost::asio::deadline_timer::traits_type::now())
        {  
            if(timer) DEL(timer);
            return;
        }

        timer->expires_at(timer->expires_at()+boost::posix_time::seconds(1));
        timer->async_wait(boost::bind(callback, boost::asio::placeholders::error, timer));
    }
}

Timers are working well. However, when strange bug arise, I always doubted first my asio code because I couldn`t find similar asio code as I wrote.

Without any mutex or synchronization, can I register timer in multiple thread?

Also, if you find any problems in mycode, please advice me.

Thank you for reading.

In `callback` you first delete `timer`, then call its `expires_at` and `async_wait` member functions. — Igor R., Mar 05 '14 at 06:10
Thx. Actually my real code has return statement. I fixed my code. — Jongju Kim, Mar 05 '14 at 06:40

score 3 · Answer 1 · answered Mar 05 '14 at 16:54

The deadline timer instances are not threadsafe.

Separate instances are threadsafe. So, either use separate timers, or add synchronization to the access.

Documentation link:

http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference/deadline_timer.html#boost_asio.reference.deadline_timer.thread_safety

score 1 · Answer 2 · answered Mar 05 '14 at 22:06

You should notice that your callback function will always be invoked in the thread were io_service.run() is called, which is service_thread in your case. Therefore you access the timer objects on two threads without synchronization, which is not safe without synchronization.

However the exact situation depends on your complete code (what is in the ... sections). If you do it exactly like in your example (only creating and starting the timer in the first thread (which is guaranteed to happen before the callback) and accessing it aftwards only in the io_service thread it should be safe.

How to safely use boost deadline timer in multiple threads?

2 Answers2

Linked