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

概述(来自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   

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"> 

003 //     Copyright (c) Microsoft Corporation.  All rights reserved. 

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   

334 // File provided for Reference Use Only by Microsoft Corporation (c) 2007.

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

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));  

05  

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

07            if( i < 0) { 

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

09            } 

10   

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; 

08   

09 namespace TestMultipleThread 

10 { 

11   

12     public class ThreadWork 

13     { 

14         private System.Timers.Timer _TestTimerEvent; 

15   

16         public void StartWork() 

17         { 

18             _TestTimerEvent = new Timer(); 

19             _TestTimerEvent.Elapsed += Sum; 

20             _TestTimerEvent.Start(); 

21         } 

22   

23         public static object lockobject = new object(); 

24   

25   

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     } 

35   

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(); 

44   

45             Thread.Sleep(1000000); 

46         } 

47     } 

48 }

查看的运行结果是:

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

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

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