C#的三种定时器

三种定时器：

·关于C#中timer类 在C#里关于定时器类就有3个

1、基于 Windows 的标准计时器（System.Windows.Forms.Timer）

2、基于服务器的计时器（System.Timers.Timer）

3、线程计时器（System.Threading.Timer）

System.Windows.Forms.Timer是应用于WinForm中的，它是通过Windows消息机制实现的，类似于VB或Delphi中 的Timer控件，内部使用API SetTimer实现的。它的主要缺点是计时不精确，而且必须有消息循环，Console Application(控制台应用程序)无法使用。

 System.Timers.Timer和System.Threading.Timer非常类似，它们是通过.NET Thread Pool实现的，轻量，计时精确，对应用程序、消息没有特别的要求。System.Timers.Timer还可以应用于WinForm，完全取代上面的 Timer控件。它们的缺点是不支持直接的拖放，需要手工编码。

例：

使用System.Timers.Timer类

System.Timers.Timer t = new System.Timers.Timer(10000);//实例化Timer类，设置间隔时间为10000毫秒；

t.Elapsed += new System.Timers.ElapsedEventHandler(theout);//到达时间的时候执行事件；

t.AutoReset = true;//设置是执行一次（false）还是一直执行(true)；

t.Enabled = true;//是否执行System.Timers.Timer.Elapsed事件；

public void theout(object source, System.Timers.ElapsedEventArgs e)

{

MessageBox.Show("OK!");

}

一、基于 Windows 的标准计时器（System.Windows.Forms.Timer）

微软的注释很明确：“实现按用户定义的时间间隔引发事件的计时器。此计时器最宜用于 Windows 窗体应用程序中，并且必须在窗口中使用。”，在线程中使用，其相应的事件是不会触发的。

首先注意一点就是：Windows 计时器是为单线程环境设计的，此计时器从Visual Basic 1.0 版起就存在于该产品中，并且基本上未做改动，这个计时器是使用最简单的一种，只要把工具箱中的Timer控件拖到窗体上，然后设置一下事件和间隔时间等属性就可以了，实验出来的结果也完全符合单线程的特点：

 　　1、当启动此计时器后，会在下方子线程ID列表中显示子线程ID，并且和主线程ID相同

 　　private void formsTimer_Tick（object sender， EventArgs e）
 　　{
 　　　　i++；
 　　　　lblSubThread.Text += "子线程执行，线程ID：" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString（） + "\r\n"；
 　　}

　　2、当单击主线程暂停5秒后，子线程会暂停执行，并且当5秒之后不会执行之前被暂停的子线程，而是直接执行后面的子线程（也就是会少输出几行值）

 　　System.Threading.Thread.Sleep（5000）；

 　  3、在子进程的事件中暂停5秒会导致主窗口相应无响应5秒

       4、定义一个线程静态变量：

 　　[ThreadStatic]

 　　private static int i = 0；

 　　在子线程事件中每次加一，再点击线程静态变量值会得到增加后的i值

二、基于服务器的计时器（System.Timers.Timer）

 　　System.Timers.Timer不依赖窗体，是从线程池唤醒线程，是传统的计时器为了在服务器环境上运行而优化后的更新版本，在VS2005的工具箱中没有提供现成的控件，需要手工编码使用此计时器。

 　　使用方式有两种，

 　　1、通过SynchronizingObject属性依附于窗体

 　　System.Timers.Timer  timersTimer = new System.Timers.Timer（）；

 　　timersTimer.Enabled = false；

 　　timersTimer.Interval = 100；

 　　timersTimer.Elapsed += new System.Timers.ElapsedEventHandler（timersTimer_Elapsed）；

 　　timersTimer.SynchronizingObject = this；

 　　通过这种方式来使用，实验效果几乎和基于 Windows 的标准计时器一样，只是在上面的第二条实验中，虽然也会暂停子线程的执行，不过在5秒之后把之前排队的任务都执行掉（也就是不会少输出几行值）

　　2、不使用SynchronizingObject属性

 　　这种方式就是多线程的方式了，即启动的子线程和主窗体不在一个线程。不过这样也存在一个问题：由于子线程是单独的一个线程，那么就不能访问住窗体中的控件了，只能通过代理的方式来访问：

 　　delegate void SetTextCallback（string text）；

void timersTimer_Elapsed（object sender， System.Timers.ElapsedEventArgs e）
{
　　//使用代理
　　string text = "子线程执行，线程ID：" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString（） + "\r\n"；
　　SetTextCallback d = new SetTextCallback（SetText）；
　　this.Invoke（d， new object[] { text }）；
　　i++；
}

private void SetText（string text）
{
　　lblSubThread.Text += text；
}

　　这样我们再次实验就会得到如下的结果：

 　　1、当启动此计时器后，会在下方子线程ID列表中显示子线程ID，并且和主线程ID不相同

 　　2、当单击主线程暂停5秒后，子线程会一直往下执行（界面上可能看不出来，不过通过在子线程输出文件的方式可以很方便的看出来）

 　　3、在子进程的事件中暂停5秒不会导致主窗口无响应

 　　4、在子线程事件中每次给线程静态变量加一，再点击线程静态变量值得到的值还是0（不会改变主窗口中的线程静态变量）

三、线程计时器（System.Threading.Timer）

 　　线程计时器也不依赖窗体，是一种简单的、轻量级计时器，它使用回调方法而不是使用事件，并由线程池线程提供支持。

 　　对消息不在线程上发送的方案中，线程计时器是非常有用的。

 　　使用方法如下：

System.Threading.Timer threadTimer；
public void ThreadMethod（Object state）
{
　　//使用代理
　　string text = "子线程执行，线程ID：" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString（） + "\r\n"；
　　SetTextCallback d = new SetTextCallback（SetText）；
　　this.Invoke（d， new object[] { text }）；
　　i++；
}

private void Form1_Load（object sender， EventArgs e）
{
　　threadTimer = new System.Threading.Timer（new System.Threading.TimerCallback（ThreadMethod）， null， -1， -1）；
}

System.Threading.Timer 是由线程池调用的。所有的Timer对象只使用了一个线程来管理。这个线程知道下一个Timer对象在什么时候到期。下一个Timer对象到期时，线程就会唤醒，在内部调用ThreadPool 的 QueueUserWorkItem，将一个工作项添加到线程池队列中，使你的回调方法得到调用。如果回调方法的执行时间很长，计时器可能（在上个回调还没有完成的时候）再次触发。这可能造成多个线程池线程同时执行你的回调方法。

周期到就会再次调用回调方法，而不管上次是否执行完成，形成多个线程池线程同时执行！

参数
callback : 一个Object 类型参数的委托，周期调用的函数。
state: callback 委托调用时的参数。
dueTime: 定时器延时多久开始调用。单位 毫秒
period: 定时器每隔多久调用一次。单位 毫秒

不能使用局部变量来创建指向一个线程定时器。因为局部变量会被GC回收，导致定时器失效。
比如下面的例子:

static void Main(string[] args) 
{
    Run();
    //为了加开GC垃圾回收,不停的创建对象
    for (int i = 0; i < 10000; i++) 
    {
        cc tmp = new cc();
        Thread.Sleep(10);
    }
    Console.ReadKey();
}

static int id;

static void Run() 
{
    Timer timer = new Timer(DoTime, null, 500, 500);
}

static void DoTime(object obj) 
{
    Console.WriteLine(id++);
}

class cc
{ 
    public int[] a = new int[1000];
}

定时器执行4次后停止了。定时器什么时候停止取决于GC什么时候回收。如果一直没有GC的回收，那么将会一直执行下去。比如把上方创建 cc 对象的代码删除。定时器将会一直执行。

可以在Main方法中使局部变量 或者 使用全局变量来存放Timer 对象 避免 clr 把Timer 回收。

        static Timer timer;

        static void Main(string[] args) {

            timer =  new Timer(DoTime, null, 500, 500);

            //为了加开GC垃圾回收,不停的创建对象
            for (int i = 0; i < 10000; i++) {
                cc tmp = new cc();
                Thread.Sleep(10);
            }

            Console.ReadKey();

        }

        static int id;

        static void DoTime(object obj) {
            Console.WriteLine(id++);
        }

如果回调方法的执行时间很长，计时器可能（在上个回调还没有完成的时候）再次触发。这可能造成多个线程池线程同时执行你的回调方法。

        static Timer timer1;

        static void Main(string[] args) {

            timer1 = new Timer(DoTime, 1, 500, 500);
            Console.ReadKey();
        }

        static int id;

        static void DoTime(object obj) {
            int idx = id ++;
            Console.WriteLine("处理开始:" + idx + "," + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1200);
            Console.WriteLine("处理完毕:" + idx + "," + Thread.CurrentThread.ManagedThreadId);
        }

定时器第一次任务还没执行完毕，第二次，第三次回调就开始了。多个线程同时并发 DoTime 方法。

回调方法运行时，id的值被COPY到线程空间，不会被其它线程的操作改变，每个DoTime 方法都有自己的线程空间。

解决方法【取消周期调用】
period 【周期调用时间】使用 Timeout.Infinite。这个参数将导致DoTime 只处理一次。
在回调方法中使用 Change方法来修改 dueTime【延时时间】，period 【周期时间】参数。period 继续使用 Timeout.Infinite. 使用这个方法要注意如果timer 在被Dispose了，使用Change 将会引发异常。
比如

        static Timer timer1;

        static void Main(string[] args) {
            timer1 = new Timer(DoTime, 1, 0, Timeout.Infinite);
            Console.ReadKey();
        }

        static int id;
        static void DoTime(object obj) {
            int idx = id ++;
            Console.WriteLine("处理开始:" + idx + "," + Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1200);
            Console.WriteLine("处理完毕:" + idx + "," + Thread.CurrentThread.ManagedThreadId);
            timer1.Change(500,Timeout.Infinite);     //设置下次调用时间
        }

使用Disponse停止定时器
如果Timer 不会再使用 则可以 使用 Dispose 方法来停止定时器。
如果定时器运行到中途，使用Dispose方法后，callback还是会执行完一个完整的生命周期，不会中途停止。并且Dispose方法不会等待 callback的这次调用完成。只是定时器下次不再调用 callback。

使用Change停止定时器
把 dueTime 参数置为-1就可以停止定时器。同样的，它不会中断在运行中的callback，只是下一次不再回调。 这个方法停止的定时器 还可以使用Change 再次利用定时器。

 四、c#每隔一段时间执行代码

方法一：调用线程执行方法，在方法中实现死循环，每个循环Sleep设定时间；

方法二：使用System.Timers.Timer类；

方法三：使用System.Threading.Timer；

using System;
using System.Collections;
using System.Threading;
  
public class Test
{
  
    public static void Main()
    {
        Test　obj = new Test();
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString());
  
        //方法一：调用线程执行方法，在方法中实现死循环，每个循环Sleep设定时间
        Thread　thread = new Thread(new ThreadStart(obj.Method1));
        thread.Start();
  
  
        //方法二：使用System.Timers.Timer类
        System.Timers.Timer　t = new System.Timers.Timer(100);//实例化Timer类，设置时间间隔
        t.Elapsed　+= new System.Timers.ElapsedEventHandler(obj.Method2);//到达时间的时候执行事件
        t.AutoReset　= true;//设置是执行一次（false）还是一直执行(true)
        t.Enabled　= true;//是否执行System.Timers.Timer.Elapsed事件
        while (true)
        {
            Console.WriteLine("test_" +Thread.CurrentThread.ManagedThreadId.ToString());
            Thread.Sleep(100);
        }
  
  
        //方法三：使用System.Threading.Timer
        //Timer构造函数参数说明：
        //Callback：一个　TimerCallback 委托，表示要执行的方法。
        //State：一个包含回调方法要使用的信息的对象，或者为空引用（Visual　Basic 中为 Nothing）。
        //dueTime：调用　callback 之前延迟的时间量（以毫秒为单位）。指定 Timeout.Infinite 以防止计时器开始计时。指定零 (0) 以立即启动计时器。
        //Period：调用　callback 的时间间隔（以毫秒为单位）。指定 Timeout.Infinite 可以禁用定期终止。
        System.Threading.Timer　threadTimer = new System.Threading.Timer(new System.Threading.TimerCallback(obj.Method3),null, 0, 100);
        while (true)
        {
            Console.WriteLine("test_" +Thread.CurrentThread.ManagedThreadId.ToString());
            Thread.Sleep(100);
        } 
        Console.ReadLine();
    }
  
  
    void Method1()
    {
        while (true)
        {
            Console.WriteLine(DateTime.Now.ToString()+ "_" + Thread.CurrentThread.ManagedThreadId.ToString());
            Thread.CurrentThread.Join(100);//阻止设定时间
        }
    }
  
  
    void Method2(object source,System.Timers.ElapsedEventArgs e)
    {
        Console.WriteLine(DateTime.Now.ToString()+ "_" + Thread.CurrentThread.ManagedThreadId.ToString());
    }
  
  
    void Method3(Objectstate)
    {
        Console.WriteLine(DateTime.Now.ToString()+ "_" +Thread.CurrentThread.ManagedThreadId.ToString());
    }
}