.NET System.Timers.Timer的原理和使用(开发定时执行程序)

浏览数：21 / 时间：2015年06月09日

概述(来自MSDN)

Timer 组件是基于服务器的计时器，它使您能够指定在应用程序中引发Elapsed 事件的周期性间隔。然后可以操控此事件以提供定期处理。例如，假设您有一台关键性服务器，必须每周7 天、每天24 小时都保持运行。可以创建一个使用Timer 的服务，以定期检查服务器并确保系统开启并在运行。如果系统不响应，则该服务可以尝试重新启动服务器或通知管理员。

基于服务器的Timer 是为在多线程环境中用于辅助线程而设计的。服务器计时器可以在线程间移动来处理引发的Elapsed 事件，这样就可以比Windows 计时器更精确地按时引发事件。

基于Interval 属性的值，Timer 组件引发Elapsed 事件。可以处理该事件以执行所需的处理。例如，假设您有一个联机销售应用程序，它不断向数据库发送销售订单。编译发货指令的服务分批处理订单，而不是分别处理每个订单。可以使用Timer 每30 分钟启动一次批处理。

注意

当AutoReset设置为false时，Timer只在第一个Interval过后引发一次Elapsed事件。若要保持以Interval时间间隔引发Elapsed 事件，请将AutoReset设置为true。

Elapsed事件在ThreadPool线程上引发。如果Elapsed事件的处理时间比Interval长，在另一个hreadPool线程上将会再次引发此事件。因此，事件处理程序应当是可重入的。

注意

在一个线程调用Stop 方法或将Enabled 属性设置为false 的同时，可在另一个线程上运行事件处理方法。这可能导致在计时器停止之后引发Elapsed 事件。Stop 方法的示例代码演示了一种避免此争用条件的方法。

如果和用户界面元素（如窗体或控件）一起使用Timer，请将包含有Timer 的窗体或控件赋值给SynchronizingObject 属性，以便将此事件封送到用户界面线程中。Timer 在运行时是不可见的。

几点说明

1 private System.Timers.Timer _TestTimerEvent= new Timer();

1、默认的周期是0.1秒执行一次；

2、AutoReset的初始值为true.

3、它的timer机制和System.Threading.Timer 原理是一样的。

4、每次周期(Timer)运行一次会新起一个线程。

5、如果Elapsed事件的处理时间比Interval长，它每个周期执行都会新起一个线程，这个线程的执行时间不受interval的限定，可以比interval长，因为一个新周期执行，又会新起一个线程，Timer起的线程周期就是事件处理时间。

我们来看它的实现代码.（.net framework 提供的）.

001 //------------------------------------------------------------------------------

002 // <copyright file="Timer.cs" company="Microsoft">

004 // </copyright>

005 //-----------------------------------------------------------------------------

006

007 namespace System.Timers {

008

009 using System.Runtime.InteropServices;

010 using System.Security;

011 using System.Security.Permissions;

012 using System.Threading;

013 using System.ComponentModel;

014 using System.ComponentModel.Design;

015 using System;

016 using Microsoft.Win32;

017 using Microsoft.Win32.SafeHandles;

018

019 /// <devdoc>

020 /// <para>Handles recurring events in an application.</para>

021 /// </devdoc>

022 [

023 DefaultProperty("Interval"),

024 DefaultEvent("Elapsed"),

025 HostProtection(Synchronization=true, ExternalThreading=true)

026 ]

027 public class Timer : Component, ISupportInitialize {

028 private double interval;

029 private bool enabled;

030 private bool initializing;

031 private bool delayedEnable;

032 private ElapsedEventHandler onIntervalElapsed;

033 private bool autoReset;

034 private ISynchronizeInvoke synchronizingObject;

035 private bool disposed;

036 private System.Threading.Timer timer;

037 private TimerCallback callback;

038 private Object cookie;

039

040 /// <devdoc>

041 /// <para>Initializes a new instance of the <see cref=‘System.Timers.Timer‘/> class, with the properties

042 /// set to initial values.</para>

043 /// </devdoc>

044 public Timer()

045 : base() {

046 interval = 100;

047 enabled = false;

048 autoReset = true;

049 initializing = false;

050 delayedEnable = false;

051 callback = new TimerCallback(this.MyTimerCallback);

052 }

053

054 /// <devdoc>

055 /// <para>

056 /// Initializes a new instance of the <see cref=‘System.Timers.Timer‘/> class, setting the <see cref=‘System.Timers.Timer.Interval‘/> property to the specified period.

057 /// </para>

058 /// </devdoc>

059 public Timer(double interval)

060 : this() {

061 if (interval <= 0)

062 throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));

063

064 int i = (int)Math.Ceiling(interval);

065 if( i < 0) {

066 throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));

067 }

068

069 this.interval = interval;

070 }

071

072 /// <devdoc>

073 /// <para>Gets or sets a value indicating whether the Timer raises the Tick event each time the specified

074 /// Interval has elapsed,

075 /// when Enabled is set to true.</para>

076 /// </devdoc>

077 [Category("Behavior"), TimersDescription(SR.TimerAutoReset), DefaultValue(true)]

078 public bool AutoReset {

079 get {

080 return this.autoReset;

081 }

082

083 set {

084 if (DesignMode)

085 this.autoReset = value;

086 else if (this.autoReset != value) {

087 this.autoReset = value;

088 if( timer != null) {

089 UpdateTimer();

090 }

091 }

092 }

093 }

094

095 /// <devdoc>

096 /// <para>Gets or sets a value indicating whether the <see cref=‘System.Timers.Timer‘/>

097 /// is able

098 /// to raise events at a defined interval.</para>

099 /// </devdoc>

100 //[....] - The default value by design is false, don‘t change it.

101 [Category("Behavior"), TimersDescription(SR.TimerEnabled), DefaultValue(false)]

102 public bool Enabled {

103 get {

104 return this.enabled;

105 }

106

107 set {

108 if (DesignMode) {

109 this.delayedEnable = value;

110 this.enabled = value;

111 }

112 else if (initializing)

113 this.delayedEnable = value;

114 else if (enabled != value) {

115 if (!value) {

116 if( timer != null) {

117 cookie = null;

118 timer.Dispose();

119 timer = null;

120 }

121 enabled = value;

122 }

123 else {

124 enabled = value;

125 if( timer == null) {

126 if (disposed) {

127 throw new ObjectDisposedException(GetType().Name);

128 }

129

130 int i = (int)Math.Ceiling(interval);

131 cookie = new Object();

132 timer = new System.Threading.Timer(callback, cookie, i, autoReset? i:Timeout.Infinite);

133 }

134 else {

135 UpdateTimer();

136 }

137 }

138

139 }

140 }

141 }

142

143

144 private void UpdateTimer() {

145 int i = (int)Math.Ceiling(interval);

146 timer.Change(i, autoReset? i :Timeout.Infinite );

147 }

148

149 /// <devdoc>

150 /// <para>Gets or

151 /// sets the interval on which

152 /// to raise events.</para>

153 /// </devdoc>

154 [Category("Behavior"), TimersDescription(SR.TimerInterval), DefaultValue(100d), RecommendedAsConfigurable(true)]

155 public double Interval {

156 get {

157 return this.interval;

158 }

159

160 set {

161 if (value <= 0)

162 throw new ArgumentException(SR.GetString(SR.TimerInvalidInterval, value, 0));

163

164 interval = value;

165 if (timer != null) {

166 UpdateTimer();

167 }

168 }

169 }

170

171

172 /// <devdoc>

173 /// <para>Occurs when the <see cref=‘System.Timers.Timer.Interval‘/> has

174 /// elapsed.</para>

175 /// </devdoc>

176 [Category("Behavior"), TimersDescription(SR.TimerIntervalElapsed)]

177 public event ElapsedEventHandler Elapsed {

178 add {

179 onIntervalElapsed += value;

180 }

181 remove {

182 onIntervalElapsed -= value;

183 }

184 }

185

186 /// <devdoc>

187 /// <para>

188 /// Sets the enable property in design mode to true by default.

189 /// </para>

190 /// </devdoc>

191 /// <internalonly/>

192 public override ISite Site {

193 set {

194 base.Site = value;

195 if (this.DesignMode)

196 this.enabled= true;

197 }

198

199 get {

200 return base.Site;

201 }

202 }

203

204

205 /// <devdoc>

206 /// <para>Gets or sets the object used to marshal event-handler calls that are issued when

207 /// an interval has elapsed.</para>

208 /// </devdoc>

209 [

210 Browsable(false),

211 DefaultValue(null),

212 TimersDescription(SR.TimerSynchronizingObject)

213 ]

214 public ISynchronizeInvoke SynchronizingObject {

215 get {

216 if (this.synchronizingObject == null && DesignMode) {

217 IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));

218 if (host != null) {

219 object baseComponent = host.RootComponent;

220 if (baseComponent != null && baseComponent is ISynchronizeInvoke)

221 this.synchronizingObject = (ISynchronizeInvoke)baseComponent;

222 }

223 }

224

225 return this.synchronizingObject;

226 }

227

228 set {

229 this.synchronizingObject = value;

230 }

231 }

232

233 /// <devdoc>

234 /// <para>

235 /// Notifies

236 /// the object that initialization is beginning and tells it to stand by.

237 /// </para>

238 /// </devdoc>

239 public void BeginInit() {

240 this.Close();

241 this.initializing = true;

242 }

243

244 /// <devdoc>

245 /// <para>Disposes of the resources (other than memory) used by

246 /// the <see cref=‘System.Timers.Timer‘/>.</para>

247 /// </devdoc>

248 public void Close() {

249 initializing = false;

250 delayedEnable = false;

251 enabled = false;

252

253 if (timer != null ) {

254 timer.Dispose();

255 timer = null;

256 }

257 }

258

259 /// <internalonly/>

260 /// <devdoc>

261 /// </devdoc>

262 protected override void Dispose(bool disposing) {

263 Close();

264 this.disposed = true;

265 base.Dispose(disposing);

266 }

267

268 /// <devdoc>

269 /// <para>

270 /// Notifies the object that initialization is complete.

271 /// </para>

272 /// </devdoc>

273 public void EndInit() {

274 this.initializing = false;

275 this.Enabled = this.delayedEnable;

276 }

277

278 /// <devdoc>

279 /// <para>Starts the timing by setting <see cref=‘System.Timers.Timer.Enabled‘/> to <see langword=‘true‘/>.</para>

280 /// </devdoc>

281 public void Start() {

282 Enabled = true;

283 }

284

285 /// <devdoc>

286 /// <para>

287 /// Stops the timing by setting <see cref=‘System.Timers.Timer.Enabled‘/> to <see langword=‘false‘/>.

288 /// </para>

289 /// </devdoc>

290 public void Stop() {

291 Enabled = false;

292 }

293

294 private void MyTimerCallback(object state) {

295 // System.Threading.Timer will not cancel the work item queued before the timer is stopped.

296 // We don‘t want to handle the callback after a timer is stopped.

297 if( state != cookie) {

298 return;

299 }

300

301 if (!this.autoReset) {

302 enabled = false;

303 }

304

305 FILE_TIME filetime = new FILE_TIME();

306 GetSystemTimeAsFileTime(ref filetime);

307 ElapsedEventArgs elapsedEventArgs = new ElapsedEventArgs(filetime.ftTimeLow, filetime.ftTimeHigh);

308 try {

309 // To avoid ---- between remove handler and raising the event

310 ElapsedEventHandler intervalElapsed = this.onIntervalElapsed;

311 if (intervalElapsed != null) {

312 if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired)

313 this.SynchronizingObject.BeginInvoke(intervalElapsed, new object[]{this, elapsedEventArgs});

314 else

315 intervalElapsed(this, elapsedEventArgs);

316 }

317 }

318 catch {

319 }

320 }

321

322 [StructLayout(LayoutKind.Sequential)]

323 internal struct FILE_TIME {

324 internal int ftTimeLow;

325 internal int ftTimeHigh;

326 }

327

328 [DllImport(ExternDll.Kernel32), SuppressUnmanagedCodeSecurityAttribute()]

329 internal static extern void GetSystemTimeAsFileTime(ref FILE_TIME lpSystemTimeAsFileTime);

330 }

331 }

332

333

在初始化的时候它的代码实现是这样的.

1 public Timer()

2 : base() {

3 interval = 100;

4 enabled = false;

5 autoReset = true;

6 initializing = false;

7 delayedEnable = false;

8 callback = new TimerCallback(this.MyTimerCallback);

9 }

而如果你是这样的话

01 public Timer(double interval)

02 : this() {

03 if (interval <= 0)

04 throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));

06 int i = (int)Math.Ceiling(interval);

07 if( i < 0) {

08 throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval));

09 }

11 this.interval = interval;

12 }

你就需要再设置下AutoReset = True;

我们加载事件的Elapsed的代码实现是这样的.

01 /// <devdoc>

02 /// <para>Occurs when the <see cref=‘System.Timers.Timer.Interval‘/> has

03 /// elapsed.</para>

04 /// </devdoc>

05 [Category("Behavior"), TimersDescription(SR.TimerIntervalElapsed)]

06 public event ElapsedEventHandler Elapsed {

07 add {

08 onIntervalElapsed += value;

09 }

10 remove {

11 onIntervalElapsed -= value;

12 }

13 }

对它的基本原理有一定了解后，我们开始写一个简单的实现程序。

01 using System;

02 using System.Collections.Generic;

03 using System.Linq;

04 using System.Text;

05 using System.Threading;

06 using Timer = System.Timers.Timer;

07 using System.Timers;

09 namespace TestMultipleThread

10 {

12 public class ThreadWork

13 {

14 private System.Timers.Timer _TestTimerEvent;

16 public void StartWork()

17 {

18 _TestTimerEvent = new Timer();

19 _TestTimerEvent.Elapsed += Sum;

20 _TestTimerEvent.Start();

21 }

23 public static object lockobject = new object();

26 private void Sum(object sender, ElapsedEventArgs e)

27 {

28 Console.WriteLine(string.Format("this is thread ID {0} execute", Thread.CurrentThread.ManagedThreadId));

29 for (int i = 0; i < 10000; i++)

30 {

31 Thread.Sleep(10);

32 }

33 }

34 }

36 class Program

37 {

38 public static void Main()

39 {

40 ThreadWork threadWork = new ThreadWork();

41 ThreadStart myThreadDelegate = new ThreadStart(threadWork.StartWork);

42 Thread myThread = new Thread(myThreadDelegate);

43 myThread.Start();

45 Thread.Sleep(1000000);

46 }

47 }

48 }

查看的运行结果是:

我们看下执行的线程数有多少

能说明的一个问题就是在timer每次执行时都会新起一个线程来执行。

郑重声明：本站内容如果来自互联网及其他传播媒体，其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。

.NET System.Timers.Timer的原理和使用(开发定时执行程序)

标签： des class 代码 src 使用 com 问题数据 http des class 代码 src 使用 com 问题数据 http

.NET System.Timers.Timer的原理和使用(开发定时执行程序)

相关文章

随机文章

您可能还喜欢

您可能还喜欢

最新图文

您可能还喜欢

您可能还喜欢

文摘排行

文章排行

推荐文章

图文排行

推荐图文