55#ifndef BITCOIN_SCHEDULER_H
66#define BITCOIN_SCHEDULER_H
77
8- //
9- // NOTE:
10- // boost::thread should be ported to std::thread
11- // when we support C++11.
12- //
138#include < condition_variable>
149#include < functional>
1510#include < list>
1611#include < map>
1712
1813#include < sync.h>
1914
20- //
21- // Simple class for background tasks that should be run
22- // periodically or once "after a while"
23- //
24- // Usage:
25- //
26- // CScheduler* s = new CScheduler();
27- // s->scheduleFromNow(doSomething, std::chrono::milliseconds{11}); // Assuming a: void doSomething() { }
28- // s->scheduleFromNow([=] { this->func(argument); }, std::chrono::milliseconds{3});
29- // boost::thread* t = new boost::thread(std::bind(CScheduler::serviceQueue, s));
30- //
31- // ... then at program shutdown, make sure to call stop() to clean up the thread(s) running serviceQueue:
32- // s->stop();
33- // t->join();
34- // delete t;
35- // delete s; // Must be done after thread is interrupted/joined.
36- //
37-
15+ /* *
16+ * Simple class for background tasks that should be run
17+ * periodically or once "after a while"
18+ *
19+ * Usage:
20+ *
21+ * CScheduler* s = new CScheduler();
22+ * s->scheduleFromNow(doSomething, std::chrono::milliseconds{11}); // Assuming a: void doSomething() { }
23+ * s->scheduleFromNow([=] { this->func(argument); }, std::chrono::milliseconds{3});
24+ * std::thread* t = new std::thread([&] { s->serviceQueue(); });
25+ *
26+ * ... then at program shutdown, make sure to call stop() to clean up the thread(s) running serviceQueue:
27+ * s->stop();
28+ * t->join();
29+ * delete t;
30+ * delete s; // Must be done after thread is interrupted/joined.
31+ */
3832class CScheduler
3933{
4034public:
@@ -43,7 +37,7 @@ class CScheduler
4337
4438 typedef std::function<void ()> Function;
4539
46- // Call func at/after time t
40+ /* * Call func at/after time t */
4741 void schedule (Function f, std::chrono::system_clock::time_point t);
4842
4943 /* * Call f once after the delta has passed */
@@ -67,23 +61,33 @@ class CScheduler
6761 */
6862 void MockForward (std::chrono::seconds delta_seconds);
6963
70- // To keep things as simple as possible, there is no unschedule.
71-
72- // Services the queue 'forever'. Should be run in a thread,
73- // and interrupted using boost::interrupt_thread
64+ /* *
65+ * Services the queue 'forever'. Should be run in a thread,
66+ * and interrupted using boost::interrupt_thread
67+ */
7468 void serviceQueue ();
7569
76- // Tell any threads running serviceQueue to stop as soon as they're
77- // done servicing whatever task they're currently servicing (drain=false)
78- // or when there is no work left to be done (drain=true)
79- void stop (bool drain=false );
70+ /* * Tell any threads running serviceQueue to stop as soon as the current task is done */
71+ void stop ()
72+ {
73+ WITH_LOCK (newTaskMutex, stopRequested = true );
74+ newTaskScheduled.notify_all ();
75+ }
76+ /* * Tell any threads running serviceQueue to stop when there is no work left to be done */
77+ void StopWhenDrained ()
78+ {
79+ WITH_LOCK (newTaskMutex, stopWhenEmpty = true );
80+ newTaskScheduled.notify_all ();
81+ }
8082
81- // Returns number of tasks waiting to be serviced,
82- // and first and last task times
83- size_t getQueueInfo (std::chrono::system_clock::time_point &first,
84- std::chrono::system_clock::time_point &last) const ;
83+ /* *
84+ * Returns number of tasks waiting to be serviced,
85+ * and first and last task times
86+ */
87+ size_t getQueueInfo (std::chrono::system_clock::time_point& first,
88+ std::chrono::system_clock::time_point& last) const ;
8589
86- // Returns true if there are threads actively running in serviceQueue()
90+ /* * Returns true if there are threads actively running in serviceQueue() */
8791 bool AreThreadsServicingQueue () const ;
8892
8993private:
@@ -106,30 +110,33 @@ class CScheduler
106110 * B() will be able to observe all of the effects of callback A() which executed
107111 * before it.
108112 */
109- class SingleThreadedSchedulerClient {
113+ class SingleThreadedSchedulerClient
114+ {
110115private:
111- CScheduler * m_pscheduler;
116+ CScheduler* m_pscheduler;
112117
113118 RecursiveMutex m_cs_callbacks_pending;
114- std::list<std::function<void ()>> m_callbacks_pending GUARDED_BY (m_cs_callbacks_pending);
119+ std::list<std::function<void ()>> m_callbacks_pending GUARDED_BY (m_cs_callbacks_pending);
115120 bool m_are_callbacks_running GUARDED_BY (m_cs_callbacks_pending) = false;
116121
117122 void MaybeScheduleProcessQueue ();
118123 void ProcessQueue ();
119124
120125public:
121- explicit SingleThreadedSchedulerClient (CScheduler * pschedulerIn) : m_pscheduler(pschedulerIn) {}
126+ explicit SingleThreadedSchedulerClient (CScheduler* pschedulerIn) : m_pscheduler(pschedulerIn) {}
122127
123128 /* *
124129 * Add a callback to be executed. Callbacks are executed serially
125130 * and memory is release-acquire consistent between callback executions.
126131 * Practically, this means that callbacks can behave as if they are executed
127132 * in order by a single thread.
128133 */
129- void AddToProcessQueue (std::function<void ()> func);
134+ void AddToProcessQueue (std::function<void ()> func);
130135
131- // Processes all remaining queue members on the calling thread, blocking until queue is empty
132- // Must be called after the CScheduler has no remaining processing threads!
136+ /* *
137+ * Processes all remaining queue members on the calling thread, blocking until queue is empty
138+ * Must be called after the CScheduler has no remaining processing threads!
139+ */
133140 void EmptyQueue ();
134141
135142 size_t CallbacksPending ();
0 commit comments