1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
//
// Timer.h
//
// Library: Foundation
// Package: Threading
// Module: Timer
//
// Definition of the Timer and related classes.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Timer_INCLUDED
#define Foundation_Timer_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Runnable.h"
#include "Poco/Mutex.h"
#include "Poco/Event.h"
#include "Poco/Thread.h"
#include "Poco/Clock.h"
namespace Poco {
class AbstractTimerCallback;
class ThreadPool;
class Foundation_API Timer: protected Runnable
/// This class implements a thread-based timer.
/// A timer starts a thread that first waits for a given start interval.
/// Once that interval expires, the timer callback is called repeatedly
/// in the given periodic interval. If the interval is 0, the timer is only
/// called once.
/// The timer callback method can stop the timer by setting the
/// timer's periodic interval to 0.
///
/// The timer callback runs in its own thread, so multithreading
/// issues (proper synchronization) have to be considered when writing
/// the callback method.
///
/// The exact interval at which the callback is called depends on many
/// factors like operating system, CPU performance and system load and
/// may differ from the specified interval.
///
/// The time needed to execute the timer callback is not included
/// in the interval between invocations. For example, if the interval
/// is 500 milliseconds, and the callback needs 400 milliseconds to
/// execute, the callback function is nevertheless called every 500
/// milliseconds. If the callback takes longer to execute than the
/// interval, the callback function will not be called until the next
/// proper interval. The number of skipped invocations since the last
/// invocation will be recorded and can be obtained by the callback
/// by calling skipped().
///
/// The timer thread is taken from a thread pool, so
/// there is a limit to the number of available concurrent timers.
{
public:
Timer(long startInterval = 0, long periodicInterval = 0);
/// Creates a new timer object. StartInterval and periodicInterval
/// are given in milliseconds. If a periodicInterval of zero is
/// specified, the callback will only be called once, after the
/// startInterval expires.
/// To start the timer, call the Start() method.
virtual ~Timer();
/// Stops and destroys the timer.
void start(const AbstractTimerCallback& method);
/// Starts the timer.
/// Create the TimerCallback as follows:
/// TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
/// timer.start(callback);
///
/// The timer thread is taken from the global default thread pool.
void start(const AbstractTimerCallback& method, Thread::Priority priority);
/// Starts the timer in a thread with the given priority.
/// Create the TimerCallback as follows:
/// TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
/// timer.start(callback);
///
/// The timer thread is taken from the global default thread pool.
void start(const AbstractTimerCallback& method, ThreadPool& threadPool);
/// Starts the timer.
/// Create the TimerCallback as follows:
/// TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
/// timer.start(callback);
void start(const AbstractTimerCallback& method, Thread::Priority priority, ThreadPool& threadPool);
/// Starts the timer in a thread with the given priority.
/// Create the TimerCallback as follows:
/// TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
/// timer.start(callback);
void stop();
/// Stops the timer. If the callback method is currently running
/// it will be allowed to finish first.
/// WARNING: Never call this method from within the callback method,
/// as a deadlock would result. To stop the timer from within the
/// callback method, call restart(0).
void restart();
/// Restarts the periodic interval. If the callback method is already running,
/// nothing will happen.
void restart(long milliseconds);
/// Sets a new periodic interval and restarts the timer.
/// An interval of 0 will stop the timer.
long getStartInterval() const;
/// Returns the start interval.
void setStartInterval(long milliseconds);
/// Sets the start interval. Will only be
/// effective before start() is called.
long getPeriodicInterval() const;
/// Returns the periodic interval.
void setPeriodicInterval(long milliseconds);
/// Sets the periodic interval. If the timer is already running
/// the new interval will be effective when the current interval
/// expires.
long skipped() const;
/// Returns the number of skipped invocations since the last invocation.
/// Skipped invocations happen if the timer callback function takes
/// longer to execute than the timer interval.
protected:
void run();
private:
volatile long _startInterval;
volatile long _periodicInterval;
Event _wakeUp;
Event _done;
long _skipped;
AbstractTimerCallback* _pCallback;
Clock _nextInvocation;
mutable FastMutex _mutex;
Timer(const Timer&);
Timer& operator = (const Timer&);
};
class Foundation_API AbstractTimerCallback
/// This is the base class for all instantiations of
/// the TimerCallback template.
{
public:
AbstractTimerCallback();
AbstractTimerCallback(const AbstractTimerCallback& callback);
virtual ~AbstractTimerCallback();
AbstractTimerCallback& operator = (const AbstractTimerCallback& callback);
virtual void invoke(Timer& timer) const = 0;
virtual AbstractTimerCallback* clone() const = 0;
};
template <class C>
class TimerCallback: public AbstractTimerCallback
/// This template class implements an adapter that sits between
/// a Timer and an object's method invoked by the timer.
/// It is quite similar in concept to the RunnableAdapter, but provides
/// some Timer specific additional methods.
/// See the Timer class for information on how
/// to use this template class.
{
public:
typedef void (C::*Callback)(Timer&);
TimerCallback(C& object, Callback method): _pObject(&object), _method(method)
{
}
TimerCallback(const TimerCallback& callback): _pObject(callback._pObject), _method(callback._method)
{
}
~TimerCallback()
{
}
TimerCallback& operator = (const TimerCallback& callback)
{
if (&callback != this)
{
_pObject = callback._pObject;
_method = callback._method;
}
return *this;
}
void invoke(Timer& timer) const
{
(_pObject->*_method)(timer);
}
AbstractTimerCallback* clone() const
{
return new TimerCallback(*this);
}
private:
TimerCallback();
C* _pObject;
Callback _method;
};
} // namespace Poco
#endif // Foundation_Timer_INCLUDED
|
