C ++`Timer`類實現

Question

我設計了一個Timer類，它每n n秒調度一次事件（使用Observer模式）。 當然它會創建一個新線程，以便不阻止調用它的線程。

然后我想 - 嗯......讓我們說100個客戶端連接到我的服務器程序，我為每個客戶端創建了3個計時器，所以我運行了300個線程。 不是很多嗎？ 它是ok ，我運行300個線程？

然后我被告知 AS3 Timer在主線程中運行。 我想知道：怎么樣？ 如何實現在主線程中運行的計時器而不是阻塞它？ 在C ++中有可能嗎？

Answer 1

一種可能的解決方案是只為所有計時器使用一個線程，並按超時排序隊列。 這個問題是當一個計時器到期並且你調用回調函數時，它將在全局計時器線程的上下文中運行而不是單獨運行。這當然可以通過為事件生成一個新線程來解決，這是然后直接加入，或者通過一個線程池來處理事件，因此主計時器線程不會“堵塞”。

Answer 2

您可以創建一個單一的計時器線程，並為每個“注冊”的客戶端創建一個樹中的條目。 密鑰是客戶端超時，值將是對客戶端的引用。 這將通過超時對客戶進行排序。

然后對於計時器，設置循環計時器，比如說每100毫秒（相應地調整）。 當計時器到期時，迭代樹刪除並調度已超時的每個客戶端。 當您達到尚未超時的客戶端超時時，迭代應該停止。

這種方法的更准確的改進是當計時器到期，並且調度客戶端，計算下一個客戶端的超時並相應地設置計時器。 這取決於解決方案需要的准確程度。

Answer 3

現在這是一個設計問題，所以每個人都有不同的意見，這也取決於你的要求，但IMO，計時器不應該決定線程策略本身 - 客戶端應該這樣做。

我不確定您期望的行為，但如果您在同一個線程上的計時器上運行300個事件，並且由於某種原因在一個事件處理程序塊上運行，則永遠不會觸發其他事件處理程序。

一種可能性是在線程上創建一個計時器，但是以一種通過線程池在其他線程上執行事件處理程序的方式實現它。 當然，仍有可能破壞事物，因為如果你有許多長時間運行的處理程序，線程池可能會耗盡。

我強烈建議不要為每個處理程序使用顯式的新線程，因為上下文切換可能會破壞性能。 線程池在平衡這個方面要好得多。

Answer 4

就在主線程中實現定時器而言，必須存在一些定期從用戶代碼調用的機制（例如，在事件輪詢期間），該機制也處理定時器。 當然，這種方法很可能是不准確的，因為它只能在主線程中的用戶代碼允許時才執行定時器。

當然，它也會在執行回調代碼時阻塞主線程。

Answer 5

你的第一個問題已經有了足夠的答案：一個處理計時器事件的線程池（一組5或10個線程）通常是這樣做的，並且每個事件的一個線程和所有事件的一個線程之間有一個很好的折衷方案。 。

關於第二個問題：使用常規編程意味着您無法在主線程中執行計時器事件處理程序。 如果可以，它會“阻塞”主線程，但如果沒有得到主線程中執行的代碼的同意和支持，這是不可能的。

主線程必須不時停止並檢查定時器是否有事件，以對象的形式從定時器中獲取參數，然后處理事件。 有很多方法可以設計這個原理，但這是你如何做到這一點的一般方法。

在Unix系統上你也可能會想到使用信號，但我認為這不是一個好主意。

Answer 6

您的服務器可以為所有計時器運行一個計時器線程。 當客戶機計時器注冊到服務器計時器輪時，此timer wheel會創建事件。 當注冊的計時器超時時，事件由計時器輪設置。 客戶端獲取定時器注冊時創建的事件的句柄。 客戶端可以等待發出注冊的定時器超時的事件。 這樣，線程創建取決於客戶端。

Answer 7

由於您使用C ++進行設計，因此可以使用Boost ASIO定時器。 我還設計了一個基於它們的Timer類，它運行良好，沒有任何線程 - 它使用異步調用操作系統，所以基本上你只需要定義一個回調，當定時器到期時調用它，然后調用定時器的async_wait功能，非阻塞。 當你聲明你的計時器對象時，你只需要傳遞一個io_service對象，它是OS的ASIO接口。這個對象負責處理異步請求和回調，所以你可以調用它的阻塞方法運行 。 在我的情況下，我不能讓主線程阻塞，所以我只有一個線程，其中這個唯一的調用阻止。

在這里，您可以找到有關如何使用Boost ASIO異步計時器的示例：

http://www.boost.org/doc/libs/1_52_0/doc/html/boost_asio/tutorial/tuttimer2.html

我的AbstractAsioTimer類被設計為子類，因此onTimerTick方法將特定於派生類的末尾。 雖然您的需求可能會略有不同，但它可能是一個很好的起點：

abstractasiotimer.hpp：

#ifndef _ABSTRACTASIOTIMER_HPP_
#define _ABSTRACTASIOTIMER_HPP_

#include <boost/asio.hpp>

/**
 * Encapsulates a POSIX timer with microsecond resolution
 */
class AbstractAsioTimer
{
  public:
    /**
     * Instantiates timer with the desired period
     * @param io ASIO interface object to the SO
     * @param timeout time in microseconds for the timer handler to be executed
     */
    AbstractAsioTimer(boost::asio::io_service& io, unsigned int timeout);

    /**
     * Destructor
     */
    virtual ~AbstractAsioTimer();

    /**
     * Starts timer operation
     */
    void timerStart();

    /**
     * Stops timer operation
     */
    void timerStop();

    /**
     * Returns timer operation state
     */
    bool isRunning() const;

    /**
     * Returns a reference to the underlying io_service
     */
    boost::asio::io_service& get_io_service();

  protected:
    /**
     * Timer handler to execute user specific code
     * @note must be reimplemented in derived classes
     */
    virtual void onTimerTick() = 0;

  private:
    /**
     * Callback to be executed on timer expiration. It is responsible
     * for calling the 'onTimerTick' method and restart the timer if 
     * it remains active
     */
    void timerExpired(const boost::system::error_code& error);

    boost::asio::deadline_timer timer; /**< ASIO timer object */
    unsigned int timeout; /**< Timer period in microseconds */
    bool running; /**< Flag to indicate whether the timer is active */
};
#endif

abstractasiotimer.cpp：

#include <iostream>
#include <boost/bind.hpp>
#include <boost/concept_check.hpp>
#include "abstractasiotimer.hpp"

using namespace boost::asio;

AbstractAsioTimer::AbstractAsioTimer(boost::asio::io_service& io, 
                                     unsigned int timeout):
                                     timer(io), timeout(timeout),
                                     running(false)
{

}

AbstractAsioTimer::~AbstractAsioTimer()
{
  running = false;
  timer.cancel();
}

void AbstractAsioTimer::timerExpired(const boost::system::error_code& error) {

  if (!error) {
    onTimerTick();
    //Restart timer
    timerStart();
  }
  else {
    running = false;
    std::cerr << "Timer stopped: " << error.message() << std::endl;
  }
}

void AbstractAsioTimer::timerStart()
{
  timer.expires_from_now(boost::posix_time::microseconds(timeout));
  timer.async_wait(boost::bind(&AbstractAsioTimer::timerExpired,
                   this, placeholders::error));
  running = true;
}

void AbstractAsioTimer::timerStop() {
  running = false;
  timer.cancel();
}

bool AbstractAsioTimer::isRunning() const {
  return running;
}

io_service& AbstractAsioTimer::get_io_service()
{
  return timer.get_io_service();
}