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
.