Tengo este código para una clase personalizada ‘sau_timer’:

sau_timer::sau_timer(int secs, timerparam f, vector<string> params) : strnd(io), 
    t(io, boost::posix_time::seconds(secs))
{
    assert(secs > 0);
    this->f = f;
    this->params = params;
    t.async_wait(strnd.wrap(boost::bind(&sau_timer::exec, this, _1)));
    boost::thread thrd(boost::bind(&boost::asio::io_service::run, &io));
    io.run();
}

void sau_timer::exec(const boost::system::error_code&) {
    (f)(params);
}

Que yo quiero así que cuando hago una sau_timer objeto, el temporizador se iniciará, pero permitir la ejecución del programa a seguir. Por ejemplo, este es el main():

int main(int argc, char* argv[])
{
    vector<string> args(1);
    args[0] = "Hello!";
    sau_timer timer_test(3, sau_prompt, args);
    args[0] = "First!";
    sau_prompt(args);
    timer_test.thrd.join();
    return 0;
}

Mi intención aquí es que timer_test se realiza, a partir de un temporizador que se espera tres segundos antes de llamar a sau_prompt(«Hola!»), pero que sau_prompt(«Primero!») le llama por primera vez. Por el momento, Hola se muestra en el símbolo del sistema antes de la Primera, lo que indica que el temporizador está deteniendo todo el programa durante tres segundos antes de permitir que continúe. Quiero el temporizador para que se ejecute en segundo plano.

¿Qué estoy haciendo mal? El código se compila…

Gracias.

InformationsquelleAutor Xenoprimate | 2009-08-27

2 Comentarios

  1. 6

    Estás llamando «io.run()» en sau_timer – que esencialmente dice el asio reactor de proceso de cualquier/todos los pendientes asíncrona de eventos si se puede.

    Usted debe llamar a ejecutar o después de tener la configuración de los eventos, que es como se hace normalmente. echa un vistazo a los ejemplos en el asio de la documentación.

    #include <iostream> 
    #include <asio.ch> 
    
    #include </potencia shared_ptr.ch> 
    #include </potencia enable_shared_from_this.ch> 
    #include </potencia lexical_cast.ch> 
    #include </potencia fecha_hora.ch> 
    #include </potencia hilo.ch> 
    
    
    clase event_timer 
    { 
    público: 
    
    event_timer(asio::io_service& io_service, 
    const std::size_t& tid, 
    const std::size_t& intervalo = 5) 
    : io_service_(io_service), 
    timer_(io_service), 
    tid_(tid), 
    interval_(intervalo), 
    tick_count_(0), 
    total_diff_(0) 
    { 
    } 
    
    void start() 
    { 
    timer_.cancel(); 
    initiate_timer(); 
    } 
    
    void stop() 
    { 
    timer_.cancel(); 
    } 
    
    void set_interval(const std::size_t& milisegundos) 
    { 
    interval_ = milisegundos; 
    } 
    
    privado: 
    
    inline void initiate_timer() 
    { 
    si (interval_) 
    { 
    timer_.expires_from_now(boost::posix_time::milisegundos(interval_)); 
    timer_.async_wait( 
    boost::bind(&event_timer::handle_timer_event,este, 
    asio::marcadores de posición::error)); 
    before_ = boost::posix_time::microsec_clock::universal_time(); 
    } 
    } 
    
    inline void handle_timer_event(const asio::codigo_error& error) 
    { 
    si (!error && interval_) 
    { 
    after_ = boost::posix_time::microsec_clock::universal_time(); 
    boost::posix_time::time_duration duración = after_ - before_; 
    total_diff_ += std::abs(interval_ de duración.total_milliseconds()); 
    ++tick_count_; 
    si (tick_count_ < 200) 
    initiate_timer(); 
    otra cosa 
    std::cout << "Timer["<< tid_ <<"]\tTick["<< tick_count_ <<"] Media Diff: "<< total_diff_ /(1.0 * tick_count_) << std::endl; 
    } 
    } 
    
    asio::io_service& io_service_; 
    std::size_t tid_; 
    std::size_t interval_; 
    std::size_t tick_count_; 
    asio::deadline_timer timer_; 
    boost::posix_time::ptime before_; 
    boost::posix_time::ptime after_; 
    std::size_t total_diff_; 
    }; 
    
    int main() 
    { 
    
    std::cout << "Prueba de Temporizador" << std::endl; 
    
    asio::io_service io_service; 
    
    trate de 
    { 
    const std::size_t et_cnt = 1000; 
    std::vector<event_timer*> et_lst; 
    
    for(unsigned int i = 0; i < et_cnt; ++i) 
    { 
    et_lst.push_back(nueva event_timer(io_service,i,10)); 
    } 
    
    for(unsigned int i = 0; i < et_cnt;) 
    { 
    et_lst[i++]->start(); 
    } 
    
    std::size_t thread_pool_size = 100; 
    
    //Crear un grupo de subprocesos para ejecutar todos los io_services. 
    std::vector<boost::shared_ptr<boost::thread> > hilos; 
    para (std::size_t i = 0; i < thread_pool_size; ++i) 
    { 
    boost::shared_ptr<boost::thread> tema(nuevo impulso::hilo(boost::bind(&asio::io_service::run, &io_service))); 
    los hilos.push_back(hilo); 
    } 
    
    //Esperar a que todos los hilos en la piscina de la salida. 
    para (std::size_t i = 0; i < hilos.size(); ++i) 
    hilos[i]->join(); 
    for(unsigned int i = 0; i < et_cnt; eliminar et_lst[i++]); 
    
    } 
    catch(std::exception& e) 
    { 
    std::cout << "Excepción": "<< e.lo que() << std::endl; 
    return 1; 
    } 
    
    return 0; 
    } 
    
    • Me puse timer_test.io.ejecutar(); debajo de la línea de sau_timer timer_test(3, sau_prompt, args); en main(), y se retira de la io.ejecutar() en el constructor de la clase, pero el efecto es el mismo. Me temo que yo lo he entendido mal?
    • El ejemplo de código debería ser suficiente para que usted pueda entender cómo asio debe ser utilizado en general. Usted ve, la idea es no crear hilos de ejecución de los objetos decir un temporizador o un receptor de objeto, sino de crear varios subprocesos que se ejecutan io_services, y dejar que los de rosca io_services ejecutar llamadas asincrónicas en una rosca/concurrente manera.
  2. 0

    teniendo en cuenta el espacio de nombres y el impulso de la versión 1.69, hay tres modificaciones deben hacerse:

    1. cambio #include <asio.hpp> en #include <boost/asio.hpp>
    2. agregar: using namespace boost; using namespace boost:asio;
    3. cambio inline void handle_timer_event(const asio::error_code& error) en void handle_timer_event(const boost::system::error_code& error)

Dejar respuesta

Please enter your comment!
Please enter your name here