दिलचस्प पोस्ट
दो चर के साथ "पाश के लिए"? क्या पायथन का आदेश दिया गया सेट है? रेलवे में www यूआरएल को गैर-www अनुरोधों को पुन: निर्देशित करें जावा से प्रवेश करें आंशिक से एक रेजर सेक्शन पॉप्युलेट करें उपयोगकर्ता नाम के माध्यम से फ़ाइल का नाम कैसे प्राप्त करें <input type = "file" />? हिस्टोग्राम gnuplot का उपयोग कर रहा है? Google मानचित्र जावास्क्रिप्ट जीओकोडर से मैं एक अक्षांश और अक्षांश कैसे वापस करूँ? क्या मैं आईफोन ओरिएंटेशन परिवर्तन पर मोबाइल सफारी में सीएसएस इवेंट को ट्रिगर कर सकता हूं? एडी्यूलर 2 में डीडी / एमएम / याय के रूप में तारीख को कैसे स्वरूपित करें? एक 32-बिट इंटेल के लिए एक डबल गोल करने के लिए एक तेज़ तरीका समझाया फाइल या असेंबली को 'न्यूटॉन्सफ्ट। जेसन' या उसकी निर्भरता में से एक लोड नहीं किया जा सका। स्पष्ट परिभाषा विधानसभा संदर्भ से मेल नहीं खाती dplyr संक्षेप: ".drop = FALSE" के समकक्ष समूहों को निर्गम में शून्य लंबाई के साथ रखने के लिए कॉलस्क्रिप्ट मॉड्यूल के अंदर एक ग्लोबल वैरिएबल कॉल करें Itextsharp में ITextExtractionStrategy और LocationTextExtractionStrategy का उपयोग कर स्ट्रिंग के समन्वय प्राप्त करना

सी ++ 11 का उपयोग करते हुए टाइमर इवेंट कैसे बनाएं?

C ++ 11 का उपयोग करके टाइमर इवेंट कैसे बनाएं?

मुझे ऐसा कुछ चाहिए जैसे: "मुझे अब से 1 सेकंड के बाद कॉल करें"।

क्या कोई पुस्तकालय है?

Solutions Collecting From Web of "सी ++ 11 का उपयोग करते हुए टाइमर इवेंट कैसे बनाएं?"

मैंने जो कुछ हासिल करना चाहते हैं, उसके बारे में एक सरल कार्यान्वयन किया। आप निम्न तर्कों के साथ later में कक्षा का उपयोग कर सकते हैं:

  • int (मिलीसेकंड कोड चलाने तक इंतजार करने के लिए)
  • bool (अगर यह सत्य तुरंत लौटता है और निर्दिष्ट समय के बाद दूसरे थ्रेड पर कोड चलाता है)
  • चर बहसें (वास्तव में जो आप std :: bind को फ़ीड करेंगे)

आप std::chrono::milliseconds को std::chrono::nanoseconds या microseconds को भी उच्च परिशुद्धता के लिए बदल सकते हैं और कोड को चलाने के लिए कितनी बार निर्दिष्ट करने के लिए दूसरा इंट और एक लूप जोड़ सकते हैं।

यहां आप जाकर आनंद लें:

 #include <functional> #include <chrono> #include <future> #include <cstdio> class later { public: template <class callable, class... arguments> later(int after, bool async, callable&& f, arguments&&... args) { std::function<typename std::result_of<callable(arguments...)>::type()> task(std::bind(std::forward<callable>(f), std::forward<arguments>(args)...)); if (async) { std::thread([after, task]() { std::this_thread::sleep_for(std::chrono::milliseconds(after)); task(); }).detach(); } else { std::this_thread::sleep_for(std::chrono::milliseconds(after)); task(); } } }; void test1(void) { return; } void test2(int a) { printf("%i\n", a); return; } int main() { later later_test1(1000, false, &test1); later later_test2(1000, false, &test2, 101); return 0; } 

आउटपुट दो सेकंड के बाद:

 101 

यदि आप Windows पर हैं, तो आप थ्रेड प्रबंधन के बारे में चिंता किए बिना कॉलबैक शेड्यूल करने के लिए संगामिति :: टाइमर वर्ग का उपयोग कर सकते हैं और वर्तमान थ्रेड को अवरोधित किए बिना कर सकते हैं।

 #include <iostream> #include <agents.h> #include <ppltasks.h> template <class T> void call_after(const T& callback, unsigned int timeInMs) { concurrency::task_completion_event<void> tce; auto call = new concurrency::call<int>( [callback, tce](int) { callback(); tce.set(); }); auto timer = new concurrency::timer<int>(timeInMs, 0, call, false); concurrency::task<void> event_set(tce); event_set.then([timer, call]() { delete call; delete timer; }); timer->start(); } int main() { std::function<void()> callback = []{ std::cout << "in callback\n"; }; call_after(callback, 1000); std::cin.get(); } 

इस आलेख को भी देखें

यदि आप एक शुद्ध खिड़कियां उत्साही हैं या पीपीएल का इस्तेमाल नहीं करते हैं, तो आप डिवाइटल विंडो थ्रेडपूल पर एक कॉलबैक शेड्यूल करने के लिए CreateWaitableTimer का उपयोग कर सकते हैं और रजिस्टर व्हाटफोरसिंगल ऑब्जेक्ट फ़ंक्शन कर सकते हैं।

 #include <Windows.h> #include <string> #include <iostream> #include <functional> #include <memory> template <class T> class Timer { public: Timer(const T& callback, long long timeInHundredNanos) { HANDLE timer = CreateWaitableTimer(nullptr, true, nullptr); if (timer == nullptr) { throw std::exception("Could not create waitable timer"); } auto state = std::make_unique<State>(timer, nullptr, callback); LARGE_INTEGER dueTime; dueTime.QuadPart = -timeInHundredNanos; if (!SetWaitableTimer(timer, &dueTime, 0, nullptr, nullptr, false)) { throw std::exception("Could not set waitable timer"); } HANDLE waitHandle; if (!RegisterWaitForSingleObject( &waitHandle, timer, [](void* state, unsigned char) { std::unique_ptr<State> callbackState((State*)state); callbackState->m_callback(); }, state.get(), INFINITE, WT_EXECUTEONLYONCE)) { throw std::exception("Could not register wait"); }; state->m_waitHandle = waitHandle; state.release(); } private: class State { public: State(HANDLE timer, HANDLE waitHandle, const T& callback) :m_timer(timer), m_waitHandle(waitHandle), m_callback(callback) { } ~State() { if (m_waitHandle != nullptr) { UnregisterWait(m_waitHandle); } if (m_timer != nullptr) { CloseHandle(m_timer); } } HANDLE m_waitHandle; HANDLE m_timer; T m_callback; }; }; template <class T> void call_after(const T& callback, unsigned int timeInMs) { Timer<T> timer(callback, timeInMs * 10000); } int main(int argc, char* argv[]) { std::function<void()> callback = []{ std::cout << "in callback\n"; }; call_after(callback, 1000); std::cin.get(); } 

यह अब तक का कोड है:

मैं वीसी ++ 2012 (कोई वैरायडिक टेम्पलेट नहीं) का उपयोग कर रहा हूं

 //header #include <thread> #include <mutex> #include <condition_variable> #include <vector> #include <chrono> #include <memory> #include <algorithm> template<class T> class TimerThread { typedef std::chrono::high_resolution_clock clock_t; struct TimerInfo { clock_t::time_point m_TimePoint; T m_User; template <class TArg1> TimerInfo(clock_t::time_point tp, TArg1 && arg1) : m_TimePoint(tp) , m_User(std::forward<TArg1>(arg1)) { } template <class TArg1, class TArg2> TimerInfo(clock_t::time_point tp, TArg1 && arg1, TArg2 && arg2) : m_TimePoint(tp) , m_User(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2)) { } }; std::unique_ptr<std::thread> m_Thread; std::vector<TimerInfo> m_Timers; std::mutex m_Mutex; std::condition_variable m_Condition; bool m_Sort; bool m_Stop; void TimerLoop() { for (;;) { std::unique_lock<std::mutex> lock(m_Mutex); while (!m_Stop && m_Timers.empty()) { m_Condition.wait(lock); } if (m_Stop) { return; } if (m_Sort) { //Sort could be done at insert //but probabily this thread has time to do std::sort(m_Timers.begin(), m_Timers.end(), [](const TimerInfo & ti1, const TimerInfo & ti2) { return ti1.m_TimePoint > ti2.m_TimePoint; }); m_Sort = false; } auto now = clock_t::now(); auto expire = m_Timers.back().m_TimePoint; if (expire > now) //can I take a nap? { auto napTime = expire - now; m_Condition.wait_for(lock, napTime); //check again auto expire = m_Timers.back().m_TimePoint; auto now = clock_t::now(); if (expire <= now) { TimerCall(m_Timers.back().m_User); m_Timers.pop_back(); } } else { TimerCall(m_Timers.back().m_User); m_Timers.pop_back(); } } } template<class T, class TArg1> friend void CreateTimer(TimerThread<T>& timerThread, int ms, TArg1 && arg1); template<class T, class TArg1, class TArg2> friend void CreateTimer(TimerThread<T>& timerThread, int ms, TArg1 && arg1, TArg2 && arg2); public: TimerThread() : m_Stop(false), m_Sort(false) { m_Thread.reset(new std::thread(std::bind(&TimerThread::TimerLoop, this))); } ~TimerThread() { m_Stop = true; m_Condition.notify_all(); m_Thread->join(); } }; template<class T, class TArg1> void CreateTimer(TimerThread<T>& timerThread, int ms, TArg1 && arg1) { { std::unique_lock<std::mutex> lock(timerThread.m_Mutex); timerThread.m_Timers.emplace_back(TimerThread<T>::TimerInfo(TimerThread<T>::clock_t::now() + std::chrono::milliseconds(ms), std::forward<TArg1>(arg1))); timerThread.m_Sort = true; } // wake up timerThread.m_Condition.notify_one(); } template<class T, class TArg1, class TArg2> void CreateTimer(TimerThread<T>& timerThread, int ms, TArg1 && arg1, TArg2 && arg2) { { std::unique_lock<std::mutex> lock(timerThread.m_Mutex); timerThread.m_Timers.emplace_back(TimerThread<T>::TimerInfo(TimerThread<T>::clock_t::now() + std::chrono::milliseconds(ms), std::forward<TArg1>(arg1), std::forward<TArg2>(arg2))); timerThread.m_Sort = true; } // wake up timerThread.m_Condition.notify_one(); } //sample #include <iostream> #include <string> void TimerCall(int i) { std::cout << i << std::endl; } int main() { std::cout << "start" << std::endl; TimerThread<int> timers; CreateTimer(timers, 2000, 1); CreateTimer(timers, 5000, 2); CreateTimer(timers, 100, 3); std::this_thread::sleep_for(std::chrono::seconds(5)); std::cout << "end" << std::endl; } 

एडवर्ड से अतुल्यकालिक समाधान:

  • नया धागा बनाएं
  • उस धागे में सो जाओ
  • उस धागे में कार्य करना

सरल है और सिर्फ आपके लिए काम कर सकता है

मैं एक और उन्नत संस्करण भी देना चाहूंगा जो इन फायदे हैं:

  • कोई धागा स्टार्टअप ओवरहेड नहीं
  • सभी समयबद्ध कार्यों को संभाल करने के लिए आवश्यक केवल एक अतिरिक्त थ्रेड प्रति प्रक्रिया

यह विशेष रूप से बड़े सॉफ़्टवेयर प्रोजेक्ट्स में उपयोगी हो सकता है, जहां आपके पास कई प्रक्रियाएं हैं जिन्हें आपकी प्रक्रिया में पुनरावृत्त रूप से निष्पादित किया गया है और आप संसाधन उपयोग (थ्रेड) और स्टार्टअप ओवरहेड के बारे में ध्यान रखते हैं।

आइडिया: एक सेवा धागा है जो सभी पंजीकृत समयबद्ध कार्यों को प्रोसेस करता है। उस के लिए बढ़ावा io_service का उपयोग करें

कोड के समान: http://www.boost.org/doc/libs/1_65_1/doc/html/boost_asio/tutorial/tuttimer2/src.html

 #include <cstdio> #include <boost/asio.hpp> #include <boost/date_time/posix_time/posix_time.hpp> int main() { boost::asio::io_service io; boost::asio::deadline_timer t(io, boost::posix_time::seconds(1)); t.async_wait([](const boost::system::error_code& /*e*/){ printf("Printed after 1s\n"); }); boost::asio::deadline_timer t2(io, boost::posix_time::seconds(1)); t2.async_wait([](const boost::system::error_code& /*e*/){ printf("Printed after 1s\n"); }); // both prints happen at the same time, // but only a single thread is used to handle both timed tasks // - namely the main thread calling io.run(); io.run(); return 0; }