c ++ Implémentation de la fonction de rappel temporisé

Pour une solution portable, vous pouvez utiliser boost::asio. Ci-dessous est une démo que j'ai écrit il y a longtemps.
Vous pouvez modifier

t.expires_from_now(boost::posix_time::seconds(1));

pour répondre vous devez dire faire appel de fonction après 200 milliseonds.

t.expires_from_now(boost::posix_time::milliseconds(200)); 

Ci-dessous est un exemple de travail. Il appelle à plusieurs reprises, mais je pense qu'il devrait être facile de l'appeler qu'une seule fois par il suffit de changer un peu.

#include <iostream>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

using namespace boost::asio;
using namespace std;

class Deadline 
{
public:
    Deadline(deadline_timer &timer) : t(timer) {
        wait();
    }

    void timeout(const boost::system::error_code &e) {
        if (e)
            return;
        cout << "tick" << endl;
        wait();
    }

    void cancel() {
        t.cancel();
    }


private:
    void wait() {
        t.expires_from_now(boost::posix_time::seconds(1)); //repeat rate here
        t.async_wait(boost::bind(&Deadline::timeout, this, boost::asio::placeholders::error));
    }

    deadline_timer &t;
};


class CancelDeadline {
public:
    CancelDeadline(Deadline &d) :dl(d) { }
    void operator()() {
        string cancel;
        cin >> cancel;
        dl.cancel();
        return;
    }
private:
    Deadline &dl;
};



int main()
{
    io_service io;
    deadline_timer t(io);
    Deadline d(t);
    CancelDeadline cd(d);
    boost::thread thr1(cd);
    io.run();
    return 0;
}



//result:
//it keeps printing tick every second until you enter cancel and enter in the console
tick
tick
tick

Voulez-vous qu'il en asynchrone, de sorte que le callback à exécuter lors de l'25 millisecondes sont plus sans bloquer le principal de l'exécution du thread? Si oui, vous pouvez exécuter la fonction de rappel dans un thread séparé de la minuterie /chronométré fonction de rappel à mettre en œuvre.

Si vous n'utilisez pas le multithreading, alors votre principal ou la fonction d'appel de
callfunctiontimed(25, funcName); la bloque lors de l'exécution d'un sommeil /usleep. Il est de votre choix
maintenant, quant à ce comportement que vous souhaitez mettre en œuvre.

La vraie solution ne serait pas aussi simple que pour multithread ou pas. Il y a des choses comme, comment voulez-vous conserver les différentes minuteries/rappels de l'information compte tenu de la fonction peut être appelée plusieurs fois avec différents délais d'attente et les fonctions.

Une façon de le faire, serait comme ceci:

1. Créer une liste triée des minuteries/rappels, triés en fonction du temps d'expiration.
2. Sur fil rouge et un fil qui ressemble à des rappels/timers, appeler thread horloge.
3. Lorsqu'un nouveau rappel est ajouté, l'ajouter dans la liste triée.
4. Le thread horloge peut être initialisée à attendre pour le moins de temps dans la liste triée, ou de la tête. Re-initialiser comme de nouveaux rappels ajouté. Il y aura un peu de maths et de prendre soin de.

5. Que le thread horloge est faite de couchage, il l'enlève et la regarde de la tête de la liste et exécute le pointeur de fonction dans un nouveau thread. Thread horloge est ré-initialisé avec le temps de sommeil sur la tête de la liste.

   main() {
           //spawn a timer thread with pthread create 
   
       callfunctiontimed(25, test); 
       callfunctiontimed(35, show);
       callfunctiontimed(4,  print);
   }
   
   callfunctionTImed(int time, (func*)function, void*data) //
   {
       //add information to sorted list of timer and callbacks
       //re-initialize sleep_time for timer thread if needed. 
       return. 
   }
   timerThread() {
       while(1){
        sleep(sleep_time);
        //look at head of timer list, remove it, call function in a new thread   
        //adjust sleep time as per new head     
       }
   }

Espérons-le, cela donne une idée de ce que je voulais dire, bien que ce n'est pas parfait et a plusieurs problèmes.