C++ `Timer` - Klasse Umsetzung

Eine mögliche Lösung besteht darin, nur einen thread für alle Timer und einer queue angeordnet durch den timeout. Das problem mit diesem ist, dass, wenn ein timer abläuft, und Sie rufen die callback-Funktion, die ausgeführt wird, im Kontext der globalen timer-thread und nicht einzeln.Dies kann natürlich gelöst werden, und erzeugt einen neuen thread nur für die Veranstaltung, die dann verbunden ist, direkt oder durch einen thread-pool für die Verarbeitung von Ereignissen, also der Haupt-timer-thread wird nicht "verstopft".

Nun, dies ist eine design-Frage, so hat jeder unterschiedliche Meinungen und es hängt auch von deinen Anforderungen, aber IMO, der timer soll sich nicht entscheiden threading-Richtlinie selbst - sollte der Kunde das tun.

Ich bin mir nicht sicher, welches Verhalten Sie erwarten, aber wenn Sie laufen 300 Veranstaltungen auf einen timer auf dem gleichen thread und eine event-handler-Blöcke aus irgendeinem Grund, andere event-Handler wird nie ausgelöst werden.

Eine Möglichkeit ist, erstellen Sie einen timer auf einen thread, aber implementieren Sie in einer Weise, dass die event-Handler werden ausgeführt, andere threads über thread-pool. Natürlich, es ist immer noch möglich, die Dinge brechen, weil, wenn Sie haben viele lang laufende Handler-thread-pool bekommen könnte, erschöpft.

Ich empfehle dringend, nicht mit expliziter neuen thread für jeden handler, als Kontextwechsel würde wahrscheinlich töten die Leistung. Thread-pool ist viel besser auf die Vereinbarkeit dieser.

Ihre erste Frage schon genug Antworten: Ein thread-pool (eine Gruppe von sagen wir 5 oder 10 Fäden), die sich mit der timer-Ereignisse ist der übliche Weg, dies zu tun und ein guter Kompromiss zwischen einem thread für jede Veranstaltung und ein thread für alle Ereignisse.

Bezüglich deiner zweiten Frage: Mit regelmäßigen Programmierung bedeutet, dass Sie nicht führen Sie die timer-event-handler in der main-thread. Wenn Sie könnte, würde es "block" Haupt-thread, aber das ist nicht möglich, ohne Zustimmung und Unterstützung aus der code-Ausführung im Haupt-thread.

Den Haupt-thread müsste dann halt von Zeit zu Zeit und überprüfen Sie, ob ein Ereignis vom timer, die Parameter aus, den timer in die form eines Gegenstandes und als das Ereignis behandeln. Es gibt viele Möglichkeiten zu entwerfen, dieses Prinzip, aber das ist die Allgemeine Art und Weise, wie Sie es tun.

Auf Unix-Systemen könnte man auch denken, der Verwendung von Signalen, aber ich glaube, dass ist keine gute Idee.

Da Sie die Konstruktion in C++ können Sie Boost-ASIO Timer für, die. Ich habe auch eine Timer-Klasse, die auf diesen basieren, und es funktioniert gut und ohne Gewinde - es nutzt asynchrone Aufrufe an die O. S., so dass im Grunde müssen Sie nur definieren Sie eine Rückruffunktion, die aufgerufen wird, wenn der timer abläuft und dann rufen Sie die timer - async_wait - Funktion, die nicht blockiert. Wenn Sie erklären, Ihre timer-Objekt, Sie müssen nur geben Sie einen io_service - Objekt, das die ASIO-Schnittstelle der O. S. Dieses Objekt ist verantwortlich für die Wartung Ihrer asynchronen Anfragen und Rückrufe, so zu tun, die Sie anrufen können Ihre Blockade-Methode laufen. In meinem Fall konnte ich nicht den Hauptthread blockieren, so hatte ich gerade ein thread, in dem diese einzigartige Anruf wurde blockiert.

Hier finden Sie Beispiele zur Verwendung der Boost ASIO asynchrone timer:

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

Meine AbstractAsioTimer - Klasse entwickelt wurde, um die Unterklassen-also die onTimerTick Methode ist spezifisch für die abgeleitete Klasse endet. Obwohl Ihr braucht vielleicht ein wenig anders, ist es vielleicht ein guter Ausgangspunkt:

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