C++ 截止期计时器奇怪的行为

我有一个这样的测试班。我想做的是继续运行这个对象中的三个计时器。但在我实例化一个对象之后，一些计时器会一直重复，而其他计时器会在3分钟后消失。有人能给我解释一下吗

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;
    }
};

类事件处理器
{
私人：
boost:：asio:：deadline_timer*m_Timer0；
boost:：asio:：deadline_timer*m_Timer1；
boost:：asio:：deadline_timer*m_Timer2；
boost:：asio:：io_服务io0；
boost:：asio:：io_服务io1；
boost:：asio:：io_服务io2；
int TimerInterval[3]；
boost:：asio:：deadline_timer*定时器[3]；
公众：
事件处理器（int p_0、int p_1、int p_2）
{   
TimerInterval[0]=p_0；
TimerInterval[1]=p_1；
TimerInterval[2]=p_2；
m_Timer0=新的boost:：asio:：deadline_计时器（io0，boost:：posix_time:：seconds（TimerInterval[0]）；
定时器[0]=m_定时器0；
m_Timer1=新的boost:：asio:：deadline_计时器（io1，boost:：posix_time:：seconds（TimerInterval[1]）；
定时器[1]=m_定时器1；
m_Timer2=新的boost:：asio:：deadline_计时器（io2，boost:：posix_time:：seconds（TimerInterval[2]）；
定时器[2]=m_定时器2；
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）；
}
私人：
void HandleExpire（const boost:：system:：error_code&p_ec，int p_TimerIndex）
{
if（p_ec==boost:：asio:：error:：operation_中止）
{
std：：cout所以您应该这样做：

#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();
}

#包括“test.h”
#包括
#包括
#包括
类事件处理器
{
私人：
std:：唯一的ptr m_定时器[3]；
boost：：asio：：io_服务；
boost：：原子时标[3]；
公众：
事件处理器（int-time0、int-time1、int-time2）
{   
TimerInterval[0]=time0；
TimerInterval[1]=time1；
TimerInterval[2]=time2；
对于（int i=0；i<3；i++）
{          
m_定时器[i]。重置(
新的boost:：asio:：deadline_计时器（服务））；
}
}
~EventProcessor（）
{
服务。停止（）；
对于（int i=0；i<3；i++）
{
m_定时器[i]->cancel（）；
}
}
无效运行（）
{
对于（int i=0；i<3；i++）
{
m_Timers[i]->从现在起过期（boost:：posix_time:：seconds（TimerInterval[i]）；
m_Timers[i]->async_wait（boost:：bind（&EventProcessor:：HandleExpire，
这
我
_1));
}
service.run（）；
}
void RunAsync（）
{
boost:：thread（boost:：bind（&EventProcessor:：Run，this））；
}
无效重置（整数i，整数秒）
{
TimerInterval[i]=秒；
m_Timers[i]->从现在起过期（boost:：posix_time:：seconds（TimerInterval[i]）；
m_Timers[i]->async_wait（boost:：bind（&EventProcessor:：HandleExpire，
这
我
_1));
}
私人：
void HandleExpire（int p_TimerIndex，const boost:：system:：error_code&error）
{
if（error==boost:：asio:：error:：operation_中止）
{
std:：cout为什么每个计时器都有自己的asio服务？为什么要启动一个新线程进行重置（而不是让一个线程一直运行底层IO服务？）在async_wait之后调用Reset很奇怪（这可能是问题的根源，因为它可能会删除async_wait添加的工作）.我试图使用一个io_服务来设置三个计时器，但似乎不起作用，因为我需要分别启动和重置它们。我的理解是io.run（）实际上是计时器开始倒计时的时间。因此，如果我需要在不同的时间启动计时器，我需要不同的io_服务。对吗？@cynric4sure：不，计时器周期从调用计时器的异步等待时开始。此外，通过将io_服务提供给boost:：asio:：io_服务：：work，可以让单个io_服务处理多个计时器对象，然后将io_service:：run方法放在一个线程（或多个线程）中。您的理解有点不正确。io_服务是一个队列，只要有“工作”要做，它就会处理对象。io_service:：run是一个阻塞函数，只要有“工作”，它就会处理队列中的工作要执行。虽然通常不手动管理此操作，但可以创建io_service:：work的具体实例，该实例将在工作对象的生命周期内保持run（）运行。但是，对于计时器调用，通常只从上一次等待的回调中调用deadlock_timer:：wait_async。这将使工作保持在队列中，从而保持run（）阻塞。还有一个问题。这个对象似乎无法正常分发。我取消了所有计时器，然后在我的分发程序中调用io.stop（），它不起作用。似乎io.run（）从未返回，即使我调用了io.stop（）在我的distructor中。如果您能解释OP的原始解决方案不起作用的原因，以及您的解决方案的不同之处，这将是一个更好的答案。@cynric4如果不确定您为什么会遇到问题，我将向我使用的类添加一个自定义析构函数，然后解决SamMiller的评论