Como está diseñando en C++, puede usar los temporizadores Boost ASIO para eso. También diseñé una clase Timer basada en ellos y funciona muy bien y sin ningún tipo de subprocesos: utiliza llamadas asíncronas al sistema operativo, por lo que básicamente solo tiene que definir una devolución de llamada que se ejecutará cuando expire el temporizador y luego llame al del temporizador Función async_wait, que no es bloqueante. Cuando declare su objeto de temporizador solo tiene que pasarle un objeto io_service que es la interfaz ASIO para el O.S. Este objeto es responsable de dar servicio a sus solicitudes asincrónicas y devoluciones de llamada, por lo que puede llamar a su método de bloqueo ejecutar. En mi caso, no podía tener el bloqueo del hilo principal, así que solo tenía un hilo en el que bloqueaba esta llamada única.
Aquí se pueden encontrar ejemplos de cómo utilizar el refuerzo ASIO temporizador asíncrono:
http://www.boost.org/doc/libs/1_52_0/doc/html/boost_asio/tutorial/tuttimer2.html
Mi AbstractAsioTimer clase fue diseñado para ser una subclase lo que el método onTimerTick sería específica a la deriva la clase termina A pesar de que sus necesidades podrían ser un poco diferente, podría ser un buen punto de partida:
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();
}
más (o por lo al menos muchas) implementaciones de temporizador realmente están bloqueando. No hay nada intrínsecamente mal con eso. Sin embargo, obviamente depende del propósito. –