deadline_timer strange behavior

Question

I have a test class like this. What I want to do is to keep running the three timers in this object. But after I instantiate an object, some timer just keeps repeating but others will disappear after like 3 mins. Can anyone explain this for me?

class EventProcessor
{
private:
    boost::asio::deadline_timer* m_Timer0;
    boost::asio::deadline_timer* m_Timer1;
    boost::asio::deadline_timer* m_Timer2;
    boost::asio::io_service io0;
    boost::asio::io_service io1;
    boost::asio::io_service io2;

    int TimerInterval[3];
    boost::asio::deadline_timer* Timers[3];
public:
    EventProcessor(int p_0, int p_1, int p_2)
    {   
        TimerInterval[0] = p_0;
        TimerInterval[1] = p_1;
        TimerInterval[2] = p_2;

        m_Timer0= new boost::asio::deadline_timer(io0, boost::posix_time::seconds(TimerInterval[0]));
        Timers[0] = m_Timer0;
        m_Timer1 = new boost::asio::deadline_timer(io1, boost::posix_time::seconds(TimerInterval[1]));
        Timers[1] = m_Timer1;
        m_Timer2 = new boost::asio::deadline_timer(io2, boost::posix_time::seconds(TimerInterval[2]));
        Timers[2] = m_Timer2;
        m_Timer0->async_wait(boost::bind(&EventProcessor::HandleExpire, this, boost::asio::placeholders::error, 0));
        m_Timer1->async_wait(boost::bind(&EventProcessor::HandleExpire, this, boost::asio::placeholders::error, 1));
        m_Timer2->async_wait(boost::bind(&EventProcessor::HandleExpire, this, boost::asio::placeholders::error, 2));
        StartWithNewThread(0);
        StartWithNewThread(1);
        StartWithNewThread(2);
    }


private:
    void HandleExpire(const boost::system::error_code& p_ec, int p_TimerIndex)
    {
        if(p_ec == boost::asio::error::operation_aborted)
        {
            std::cout << "Timer" << p_TimerIndex << " canceled" << std::endl;
            return;
        }
        std::cout << "Timer" << p_TimerIndex << " expired" << std::endl;
        //Reset(p_OriginalTimer, TimerInterval[p_TimerIndex], p_TimerIndex);
        boost::thread Thread(boost::bind(&EventProcessor::Reset, this, p_TimerIndex, TimerInterval[p_TimerIndex]));
    }

    void Start(int p_Index)
    {
        boost::asio::io_service& UnderlyingIO = Timers[p_Index]->get_io_service();
        UnderlyingIO.reset();
        UnderlyingIO.run();
        UnderlyingIO.stop();
        return;
    }

    void StartWithNewThread(int p_Index)
    {
        boost::thread Thread(boost::bind(&EventProcessor::Start, this, p_Index));
        std::cout << Thread.get_id() << "<->" << "Timer" << p_Index << std::endl;
        return;
    }

public:
    void Reset(int p_Index, int p_Seconds)
    {
        Timers[p_Index]->cancel();
        Timers[p_Index]->expires_from_now(boost::posix_time::time_duration(0,0,p_Seconds,0));
        TimerInterval[p_Index] = p_Seconds;
        Timers[p_Index]->async_wait(boost::bind(&EventProcessor::HandleExpire, this, boost::asio::placeholders::error, p_Index));
        boost::asio::io_service& UnderlyingIO = Timers[p_Index]->get_io_service();
        UnderlyingIO.reset();
        UnderlyingIO.run();
        UnderlyingIO.stop();
        return;
    }
};

Answer 1

So this is how you should do it:

#include "test.h"
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/atomic.hpp>

class EventProcessor
{
private:
  std::unique_ptr<boost::asio::deadline_timer> m_Timers[3];

  boost::asio::io_service service;

  boost::atomic<int> TimerInterval[3];

public:
  EventProcessor(int time0,int time1, int time2)
  {   
    TimerInterval[0] = time0;
    TimerInterval[1] = time1;
    TimerInterval[2] = time2;

    for (int i = 0; i < 3; i++)
    {          
      m_Timers[i].reset(
        new boost::asio::deadline_timer(service));
    }
  }
  ~EventProcessor()
  {
    service.stop();
    for (int i = 0; i < 3; i++)
    {
      m_Timers[i]->cancel();
    }
  }
  void Run()
  {
    for (int i = 0; i < 3; i++)
    {
      m_Timers[i]->expires_from_now(boost::posix_time::seconds(TimerInterval[i]));
      m_Timers[i]->async_wait(boost::bind(&EventProcessor::HandleExpire,
        this,
        i,
        _1));
    }
    service.run();
  }
  void RunAsync()
  {
    boost::thread(boost::bind(&EventProcessor::Run,this));
  }
  void Reset(int i,int seconds)
  {
    TimerInterval[i] = seconds;

    m_Timers[i]->expires_from_now(boost::posix_time::seconds(TimerInterval[i]));
    m_Timers[i]->async_wait(boost::bind(&EventProcessor::HandleExpire,
      this,
      i,
      _1));
  }
private:
  void HandleExpire(int p_TimerIndex,  const boost::system::error_code& error)
  {
    if(error == boost::asio::error::operation_aborted)
    {
      std::cout << "Timer" << p_TimerIndex << " canceled" << std::endl;
      return;
    }
    std::cout << "Timer" << p_TimerIndex << " expired" << std::endl;
    //Reset(p_OriginalTimer, TimerInterval[p_TimerIndex], p_TimerIndex);

    m_Timers[p_TimerIndex]->expires_from_now(
      boost::posix_time::seconds(TimerInterval[p_TimerIndex]));
    m_Timers[p_TimerIndex]->async_wait(boost::bind(&EventProcessor::HandleExpire,
        this,
        p_TimerIndex,
        _1));
  }
};

int main()
{
  EventProcessor ev(1,2,3);
  ev.RunAsync();
  getchar();
  ev.Reset(2,4);
  getchar();
}

Granted I don't have any of the fancy checkers to see if you are currently running or not (which you totally need if you want this to be safe to use).

You can think of boost::asio::io_service as a context in which async calls can be made. It creates a FIFO queue of messages to process, and processes them where and when you tell it to. The most common way to process these messages is boost::asio::io_service::run, which will process messages until there is nothing left to be done. "nothing left to be done" is a flexible definition: it doesn't necessarily mean there is a message to process, just that there is stuff to be done. Things like a deadline timer make sure that there is "something to be done" as long as an async_wait is going on until the handler is called. You can manually enforce that there is something to be done by creating a boost::asio::io_service::work instance. This makes it so that there is "something left to be done" for the lifetime of the work object.

The deadline timer class takes care of all the async calls for you, so you don't have to spawn all those threads. The io_service performs synchronization, which is necessary to prevent annoying control issues.

So to the problem with your code:

With all those threads controlling the io_service, it is hard to tell what is actually going wrong...I have to guess on what could possibly going wrong. I'd put my money on somewhere along the line, you call a io_service::cancel before a deadline timer times out, which will stop your loop. I solve this in my code by doing all the control (calling wait_async) in one synchronous thread (the io_service::run call) and only calling io_service::cancel when I want the code to stop.