概述(来自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 在运行时是不可见的。
几点说明
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 提供的).
//------------------------------------------------------------------------------ // <copyright file="Timer.cs" company="Microsoft"> // Copyright (c) Microsoft Corporation. All rights reserved. // </copyright> //----------------------------------------------------------------------------- namespace System.Timers { using System.Runtime.InteropServices; using System.Security; using System.Security.Permissions; using System.Threading; using System.ComponentModel; using System.ComponentModel.Design; using System; using Microsoft.Win32; using Microsoft.Win32.SafeHandles; /// <devdoc> /// <para>Handles recurring events in an application.</para> /// </devdoc> [ DefaultProperty("Interval"), DefaultEvent("Elapsed"), HostProtection(Synchronization=true, ExternalThreading=true) ] public class Timer : Component, ISupportInitialize { private double interval; private bool enabled; private bool initializing; private bool delayedEnable; private ElapsedEventHandler onIntervalElapsed; private bool autoReset; private ISynchronizeInvoke synchronizingObject; private bool disposed; private System.Threading.Timer timer; private TimerCallback callback; private Object cookie; /// <devdoc> /// <para>Initializes a new instance of the <see cref='System.Timers.Timer'/> class, with the properties /// set to initial values.</para> /// </devdoc> public Timer() : base() { interval = 100; enabled = false; autoReset = true; initializing = false; delayedEnable = false; callback = new TimerCallback(this.MyTimerCallback); } /// <devdoc> /// <para> /// 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. /// </para> /// </devdoc> public Timer(double interval) : this() { if (interval <= 0) throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval)); int i = (int)Math.Ceiling(interval); if( i < 0) { throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval)); } this.interval = interval; } /// <devdoc> /// <para>Gets or sets a value indicating whether the Timer raises the Tick event each time the specified /// Interval has elapsed, /// when Enabled is set to true.</para> /// </devdoc> [Category("Behavior"), TimersDescription(SR.TimerAutoReset), DefaultValue(true)] public bool AutoReset { get { return this.autoReset; } set { if (DesignMode) this.autoReset = value; else if (this.autoReset != value) { this.autoReset = value; if( timer != null) { UpdateTimer(); } } } } /// <devdoc> /// <para>Gets or sets a value indicating whether the <see cref='System.Timers.Timer'/> /// is able /// to raise events at a defined interval.</para> /// </devdoc> //[....] - The default value by design is false, don't change it. [Category("Behavior"), TimersDescription(SR.TimerEnabled), DefaultValue(false)] public bool Enabled { get { return this.enabled; } set { if (DesignMode) { this.delayedEnable = value; this.enabled = value; } else if (initializing) this.delayedEnable = value; else if (enabled != value) { if (!value) { if( timer != null) { cookie = null; timer.Dispose(); timer = null; } enabled = value; } else { enabled = value; if( timer == null) { if (disposed) { throw new ObjectDisposedException(GetType().Name); } int i = (int)Math.Ceiling(interval); cookie = new Object(); timer = new System.Threading.Timer(callback, cookie, i, autoReset? i:Timeout.Infinite); } else { UpdateTimer(); } } } } } private void UpdateTimer() { int i = (int)Math.Ceiling(interval); timer.Change(i, autoReset? i :Timeout.Infinite ); } /// <devdoc> /// <para>Gets or /// sets the interval on which /// to raise events.</para> /// </devdoc> [Category("Behavior"), TimersDescription(SR.TimerInterval), DefaultValue(100d), RecommendedAsConfigurable(true)] public double Interval { get { return this.interval; } set { if (value <= 0) throw new ArgumentException(SR.GetString(SR.TimerInvalidInterval, value, 0)); interval = value; if (timer != null) { UpdateTimer(); } } } /// <devdoc> /// <para>Occurs when the <see cref='System.Timers.Timer.Interval'/> has /// elapsed.</para> /// </devdoc> [Category("Behavior"), TimersDescription(SR.TimerIntervalElapsed)] public event ElapsedEventHandler Elapsed { add { onIntervalElapsed += value; } remove { onIntervalElapsed -= value; } } /// <devdoc> /// <para> /// Sets the enable property in design mode to true by default. /// </para> /// </devdoc> /// <internalonly/> public override ISite Site { set { base.Site = value; if (this.DesignMode) this.enabled= true; } get { return base.Site; } } /// <devdoc> /// <para>Gets or sets the object used to marshal event-handler calls that are issued when /// an interval has elapsed.</para> /// </devdoc> [ Browsable(false), DefaultValue(null), TimersDescription(SR.TimerSynchronizingObject) ] public ISynchronizeInvoke SynchronizingObject { get { if (this.synchronizingObject == null && DesignMode) { IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost)); if (host != null) { object baseComponent = host.RootComponent; if (baseComponent != null && baseComponent is ISynchronizeInvoke) this.synchronizingObject = (ISynchronizeInvoke)baseComponent; } } return this.synchronizingObject; } set { this.synchronizingObject = value; } } /// <devdoc> /// <para> /// Notifies /// the object that initialization is beginning and tells it to stand by. /// </para> /// </devdoc> public void BeginInit() { this.Close(); this.initializing = true; } /// <devdoc> /// <para>Disposes of the resources (other than memory) used by /// the <see cref='System.Timers.Timer'/>.</para> /// </devdoc> public void Close() { initializing = false; delayedEnable = false; enabled = false; if (timer != null ) { timer.Dispose(); timer = null; } } /// <internalonly/> /// <devdoc> /// </devdoc> protected override void Dispose(bool disposing) { Close(); this.disposed = true; base.Dispose(disposing); } /// <devdoc> /// <para> /// Notifies the object that initialization is complete. /// </para> /// </devdoc> public void EndInit() { this.initializing = false; this.Enabled = this.delayedEnable; } /// <devdoc> /// <para>Starts the timing by setting <see cref='System.Timers.Timer.Enabled'/> to <see langword='true'/>.</para> /// </devdoc> public void Start() { Enabled = true; } /// <devdoc> /// <para> /// Stops the timing by setting <see cref='System.Timers.Timer.Enabled'/> to <see langword='false'/>. /// </para> /// </devdoc> public void Stop() { Enabled = false; } private void MyTimerCallback(object state) { // System.Threading.Timer will not cancel the work item queued before the timer is stopped. // We don't want to handle the callback after a timer is stopped. if( state != cookie) { return; } if (!this.autoReset) { enabled = false; } FILE_TIME filetime = new FILE_TIME(); GetSystemTimeAsFileTime(ref filetime); ElapsedEventArgs elapsedEventArgs = new ElapsedEventArgs(filetime.ftTimeLow, filetime.ftTimeHigh); try { // To avoid ---- between remove handler and raising the event ElapsedEventHandler intervalElapsed = this.onIntervalElapsed; if (intervalElapsed != null) { if (this.SynchronizingObject != null && this.SynchronizingObject.InvokeRequired) this.SynchronizingObject.BeginInvoke(intervalElapsed, new object[]{this, elapsedEventArgs}); else intervalElapsed(this, elapsedEventArgs); } } catch { } } [StructLayout(LayoutKind.Sequential)] internal struct FILE_TIME { internal int ftTimeLow; internal int ftTimeHigh; } [DllImport(ExternDll.Kernel32), SuppressUnmanagedCodeSecurityAttribute()] internal static extern void GetSystemTimeAsFileTime(ref FILE_TIME lpSystemTimeAsFileTime); } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
在初始化的时候它的代码实现是这样的.
public Timer() : base() { interval = 100; enabled = false; autoReset = true; initializing = false; delayedEnable = false; callback = new TimerCallback(this.MyTimerCallback); }
而如果你是这样的话
public Timer(double interval) : this() { if (interval <= 0) throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval)); int i = (int)Math.Ceiling(interval); if( i < 0) { throw new ArgumentException(SR.GetString(SR.InvalidParameter, "interval", interval)); } this.interval = interval; }
你就需要再设置下AutoReset = True;
我们加载事件的Elapsed的代码实现是这样的.
/// <devdoc> /// <para>Occurs when the <see cref='System.Timers.Timer.Interval'/> has /// elapsed.</para> /// </devdoc> [Category("Behavior"), TimersDescription(SR.TimerIntervalElapsed)] public event ElapsedEventHandler Elapsed { add { onIntervalElapsed += value; } remove { onIntervalElapsed -= value; } }
对它的基本原理有一定了解后,我们开始写一个简单的实现程序。
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using Timer = System.Timers.Timer; using System.Timers; namespace TestMultipleThread { public class ThreadWork { private System.Timers.Timer _TestTimerEvent; public void StartWork() { _TestTimerEvent = new Timer(); _TestTimerEvent.Elapsed += Sum; _TestTimerEvent.Start(); } public static object lockobject = new object(); private void Sum(object sender, ElapsedEventArgs e) { Console.WriteLine(string.Format("this is thread ID {0} execute", Thread.CurrentThread.ManagedThreadId)); for (int i = 0; i < 10000; i++) { Thread.Sleep(10); } } } class Program { public static void Main() { ThreadWork threadWork = new ThreadWork(); ThreadStart myThreadDelegate = new ThreadStart(threadWork.StartWork); Thread myThread = new Thread(myThreadDelegate); myThread.Start(); Thread.Sleep(1000000); } } }
查看的运行结果是:
我们看下执行的线程数有多少
能说明的一个问题就是在timer每次执行时都会新起一个线程来执行。
作者:spring yang
出处:http://www.cnblogs.com/springyangwc/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。