Comment installer une fonction de timer récurrente?

Existe-t-il un moyen simple d’installer une fonction de timer avec C ++ / stdlib? Je voudrais me débarrasser de la boucle:

using namespace std::chrono; // literal suffixes auto tNext = steady_clock::now(); while () { std::this_thread::sleep_until(tNext); tNext = tNext + 100ms; ... 

Cette fonction fonctionnera dans son propre thread.

Je devine ce que tu veux c’est

 int i = 10; auto pred = [i]() mutable {return i--;}; auto print = []{cout << "." << endl;}; timer t{500ms}; t.push({print, pred}); //asynchronously prints '.' 10 times within 5s //do anything else 

En supposant que les performances ne soient pas critiques et que le minuteur ne soit pas souvent mis à jour, les éléments suivants devraient fournir de nombreuses fonctionnalités.

 #include #include #include #include #include #include #include class timer final { public: using microseconds = std::chrono::microseconds; using predicate = std::function; using callback = std::function; using job = std::pair; explicit timer(microseconds t) : done{false}, period{t} { std::lock_guard lck(mtx); worker = std::thread([this]{ auto t = std::chrono::steady_clock::now(); while(!done.load()) { std::this_thread::sleep_until(t); std::lock_guard lck(mtx); t += period; for(auto it = jobs.begin(); it != jobs.end();) { if(it->second()) it++->first(); else it = jobs.erase(it); } } }); } ~timer() { done.store(true); worker.join(); } void set_period(microseconds t) { std::lock_guard lck(mtx); period = t; } void push(const callback& c) { std::lock_guard lck(mtx); jobs.emplace_back(c, []{return true;}); } void push(const job& j) { std::lock_guard lck(mtx); jobs.push_back(j); } private: std::mutex mtx; std::atomic_bool done; std::thread worker; std::vector jobs; microseconds period; }; 

timer appelle périodiquement les callback précédemment poussés et, lorsque le predicate évalué à false , supprime le callback de la timer . L'object timer a sa propre durée de vie et son thread de travail ne vivra que tant qu'il sera en vie.

La raison pour laquelle vous souhaitez avoir plusieurs job dans un même timer est de pouvoir les appeler ensemble, en utilisant un seul thread et en étant synchronisés les uns avec les autres.

Ne vous inquiétez pas pour le mutex sauf si vous prévoyez de mettre à jour le chronomètre> 10 000 fois par seconde, si vous avez une période <1 ms ou des callback très callback .