改进C ++中的timer（timeout event）的实现

Question

我的情况是这样的：该程序使用两个线程，我们将它们称为“发件人”和“收件人”，因为它是进程间通信的一种机制。

发送消息后，“发件人”线程停止在std::condition_variable和.wait (Lock)功能提供的std::condition_variable 。 “收件人”线程使用.notify_one()通知等待线程有关其消息的响应。

我对它的工作方式感到满意，但我想增加处理超时的功能。

我准备了以下类（我希望它是通用的，因此通知函数是从外部类定义的），但是我确信它可以更好地实现。 我想避免占用大量CPU，这就是为什么我使用std::this_thread::sleep_for ，但是我想可以用std::this_thread::yield()代替它。 我想使用例如std::future_status ，但我不知道该怎么做。 如何改善呢？ 我可以使用std c++11或boost 1.55 。

class Timer
{
    private:
    int MsLimit;
    std::atomic<bool> Stop;
    std::atomic<bool> LimitReached;
    std::thread T;
    std::mutex M;
    std::function<void()> NotifyWaitingThreadFunction;

    void Timeout()
    {
        std::unique_lock<std::mutex> Lock(M);
        std::chrono::system_clock::time_point TimerStart = std::chrono::system_clock::now();
        std::chrono::duration<long long, std::milli> ElapsedTime;
        unsigned int T = 0;
        do
        {   std::this_thread::sleep_for(std::chrono::milliseconds(5));
            std::chrono::system_clock::time_point TimerEnd = std::chrono::system_clock::now();
            ElapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(TimerEnd - TimerStart);
            T+=ElapsedTime.count();
            if((T > MsLimit) && (!Stop))
            {   LimitReached = true;
                Stop = true;
            }
        }while(!Stop);

        if(LimitReached)
        {
            NotifyWaitingThreadFunction();
        }
    }

    public:
    Timer(int Milliseconds) : MsLimit(Milliseconds)
    {

    }
    void StartTimer()
    {
        Stop = false;
        LimitReached = false;
        T = std::thread(&Timer::Timeout,this);
    }
    void StopTimer()
    {
        std::unique_lock<std::mutex> Lock(M);
        Stop = true;
        LimitReached = false;
    }
    template<class T>
    void AssignFunction(T* ObjectInstance, void (T::*MemberFunction)())
    {
        NotifyWaitingThreadFunction = std::bind(MemberFunction,ObjectInstance);
    }
};

Answer 1

您的解决方案有一个错误- 执行while循环直到MsLimit结束。 Timeout启动后， M互斥锁被阻止，并且StopTimer的调用无法中断循环，因为在Timeout释放M时，将StopTimer stop设置为true，如果(T > MsLimit)返回true并且函数结束，将会发生什么。 顺便说一句， mutex量的使用是多余的，因为Stop是原子的。

您可以使用boost库中的一种计时器，而不用创建自己的计时器。

下面的代码使用boost::asio::high_resolution_timer （增强版1.55）：

class Timer 
{
public:
  Timer (int ms)
  : timer(io), ms(ms) {}

  ~Timer() {if(t.joinable()) t.join();}

  void Start() {
    t = std::thread( [this]()
    {
      timer.expires_from_now(std::chrono::milliseconds(ms));
      timer.async_wait([this](const boost::system::error_code& ec) // start async wait
        { // lambda is called when timeout expired or error occures
          if (!ec) // if there is no error, call function
            NotifyWaitingThreadFunction();
        });
      io.run(); // process async operations
    });
  }

  void Stop() {
    timer.cancel();
  }

  template<class T>
  void AssignFunction(T* ObjectInstance, void (T::*MemberFunction)())
  {
      NotifyWaitingThreadFunction = std::bind(MemberFunction,ObjectInstance);
  }
private:
  boost::asio::io_service io; // needed for timer
  boost::asio::high_resolution_timer timer;
  std::thread t;
  int ms;
  std::function<void()> NotifyWaitingThreadFunction;
};

在创建Start方法的线程中，我们以ms为单位设置超时值，计时器由async_wait启动。 超时到期或发生错误时，将调用传递给async_wait Lambda。 因此，如果没有错误，可以调用NotifyWaitingThreadFunction 。 要停止计时器，请使用Stop方法。 停止可取消开始的异步操作，然后使用ec == boost::asio::error::operation_aborted调用lambda。 在这种情况下，lambda结束而无需调用NotifyWaitingThreadFunction 。