C# Timer解析

转至：http://blog.csdn.net/BusyDonkey/article/details/5327665

在C#里现在有3个Timer类：

• System.Windows.Forms.Timer
• System.Threading.Timer
• System.Timers.Timer

这三个Timer我想大家对System.Windows.Forms.Timer已经很熟悉了，唯一我要说的就是这个Timer在激发Timer.Tick事件的时候，事件的处理函数是在程序主线程上执行的，所以在WinForm上面用这个Timer很方便，因为在From上的所有控件都是在程序主线程上创建的，那么在Tick的处理函数中可以对Form上的所有控件进行操作，不会造成WinForm控件的线程安全问题。

 

 

 

1、Timer运行的核心都是System.Threading.ThreadPool

 

在这里要提到ThreadPool（线程池）是因为，System.Threading.Timer 和System.Timers.Timer运行的核心都是线程池，Timer每到间隔时间后就会激发响应事件，因此要申请线程来执行对应的响应函数，Timer将获取线程的工作都交给了线程池来管理，每到一定的时间后它就去告诉线程池：“我现在激发了个事件要运行对应的响应函数，麻烦你给我向操作系统要个线程，申请交给你了，线程分配下来了你就运行我给你的响应函数，没分配下来先让响应函数在这儿排队（操作系统线程等待队列）”，消息已经传递给线程池了，Timer也就不管了，因为它还有其他的事要做（每隔一段时间它又要激发事件），至于提交的请求什么时候能够得到满足，要看线程池当前的状态：

• 1、如果线程池现在有线程可用，那么申请马上就可以得到满足，有线程可用又可以分为两种情况：
  • <1>线程池现在有空闲线程，现在马上就可以用
  • <2>线程池本来现在没有线程了，但是刚好申请到达的时候，有线程运行完毕释放了，那么申请就可以用别人释放的线程。
  • 这两种情况情况就如同你去游乐园玩赛车，如果游乐园有10辆车，现在有3个人在玩，那么还剩7辆车，你去了当然可以选一辆开。另外还有一种情况就是你到达游乐园前10辆车都在开，但是你运气很好，刚到游乐园就有人不玩了，正好你坐上去就可以接着开。
• 2、如果现在线程池现在没有线程可用，也分为两种情况：
  • <1>线程池现有线程数没有达到设置的最大工作线程数，那么隔半秒钟.net framework就会向操作系统申请一个新的线程（为避免向线程分配不必要的堆栈空间，线程池按照一定的时间间隔创建新的空闲线程。该时间间隔目前为半秒，但它在 .NET Framework 的以后版本中可能会更改）。
  • <2>线程池现有工作线程数达到了设置的最大工作线程数，那么申请只有在等待队列一直等下去，直到有线程执行完任务后被释放。

 那么上面提到了线程池有最大工作线程数，其实还有最小空闲线程数，那么这两个关键字是什么意思呢：

• 1、最大工作线程数:实际上就是指的线程池能够向操作系统申请的最大线程数，这个值在.net framework中有默认值，这个默认值是根据你计算机的配置来的，当人你可以用ThreadPool.GetMaxThreads返回线程池当前最大工作线程数，你也可以同ThreadPool.SetMaxThreads设置线程池当前最大工作线程数。
• 2、最小空闲线程数：是指在程序开始后，线程池就默认向操作系统要最小空闲线程数个线程，另外这也是线程池维护的空闲线程数（如果线程池最小空闲线程数为3，当前因为一些线程执行完任务被释放，线程池现在实际上有10个空闲线程，那么线程池会让操作系统释放多余的7个线程，而只维持3个空闲线程供程序使用），因为上面说了，在执行程序的时候在要线程池申请线程有半秒的延迟时间，这也会影响程序的性能，所以把握好这个值很重要，用样你可以用ThreadPool.GetMinThreads返回线程池当前最小空闲线程数，你也可以同ThreadPool.SetMinThreads设置线程池当前最小空闲线程数。

下面是我给的例子，这个例子让线程池申请800个线程，其中设置最大工作线程数为500，800个线程任务每个都要执行100000000毫秒目的是让线程不会释放，并且让用户选择，是否预先申请500个空闲线程免受那半秒钟的延迟时间，其结果可想而知当线程申请到500的时候，线程池达到了最大工作线程数，剩余的300个申请进入漫长的等待时间:

[c-sharp] view plaincopy

1. /*************************************************** 
2.  * 项目:测试线程池 
3.  * 描述:验证线程池的最大工作线程数和最小空闲线程数 
4.  * 作者:@PowerCoder 
5.  * 日期:2010-2-22 
6. ***************************************************/  
7.   
8. using System;  
9. using System.Collections.Generic;  
10. using System.Text;  
11. using System.Threading;  
12.   
13. namespace ConsoleApplication1  
14. {  
15.     class Program  
16.     {  
17.         static int i=1;  
18.         static int MaxThreadCount = 800;  
19.   
20.         static void OutPut(object obj)  
21.         {  
22.             Console.Write("/r申请了:{0}个工作线程",i);  
23.             i++;  
24.             Thread.Sleep(100000000);//设置一个很大的等待时间，让每个申请的线程都一直执行  
25.         }  
26.   
27.         static void Main(string[] args)  
28.         {  
29.             int j;  
30.               
31.             Console.Write("是否先申请500个空闲线程以保证前500个线程在线程池中开始就有线程用(Y/N)?");//如果这里选择N，那么前两个任务是用的线程池默认空闲线程（可以用ThreadPool.GetMinThreads得到系统默认最小空闲线程数为2）申请立即得到满足，然而由于每个线程等待时间非常大都不会释放当前自己持有的线程，因此线程池中已无空闲线程所用，后面的任务需要在线程池中申请新的线程，那么新申请的每个线程在线程池中都要隔半秒左右的时间才能得到申请（原因请见下面的注释）  
32.             string key = Console.ReadLine();  
33.             if(key.ToLower()=="y")  
34.                 ThreadPool.SetMinThreads(500, 10);//设置最大空闲线程为500，就好像我告诉系统给我预先准备500个线程我来了就直接用，因为这样就不用现去申请了，在线程池中每申请一个新的线程.NET Framework 会安排一个间隔时间，目前是半秒，以后的版本MS有可能会改  
35.               
36.             int a, b;  
37.             ThreadPool.GetMaxThreads(out a,out b);  
38.             Console.WriteLine("线程池默认最大工作线程数：" + a.ToString() + "     默认最大异步 I/O 线程数：" + b.ToString());  
39.             Console.WriteLine("需要向系统申请" + MaxThreadCount.ToString()+"个工作线程");  
40.   
41.             for (j = 0; j <= MaxThreadCount-1; j++)//由于ThreadPool.GetMaxThreads返回的默认最大工作线程数为500（这个值要根据你计算机的配置来决定），那么向线程池申请大于500个线程的时候，500之后的线程会进入线程池的等待队列，等待前面500个线程某个线程执行完后来唤醒等待队列的某个线程   
42.             {  
43.                 ThreadPool.QueueUserWorkItem(new WaitCallback(OutPut));  
44.                 Thread.Sleep(10);  
45.             }  
46.   
47.             Console.ReadLine();  
48.         }  
49.     }  
50. }  

 

 

 

 

2、System.Threading.Timer

谈完了线程池，就可以开始讨论Timer，这里我们先从System.Threading.Timer开始，System.Threading.Timer的作用就是每到间隔时间后激发响应事件并执行相应函数，执行响应函数要向线程池申请线程，当然申请中会遇到一些情况在上面我们已经说了。值得注意的一点就是System.Threading.Timer在创建对象后立即开始执行，比如System.Threading.Timer timer = new System.Threading.Timer(Excute, null, 0, 10);这句执行完后每隔10毫秒就执行Excute函数不需要启动什么的。下面就举个例子，我先把代码贴出来:

[c-sharp] view plaincopy

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4. using System.Threading;  
5. using System.Diagnostics;  
6.   
7. namespace ConsoleApplication1  
8. {  
9.     class UnSafeTimer  
10.     {  
11.         static int i = 0;  
12.         static System.Threading.Timer timer;  
13.         static object mylock = new object();  
14.         static int sleep;  
15.         static bool flag;  
16.         public static Stopwatch sw = new Stopwatch();  
17.   
18.         static void Excute(object obj)  
19.         {  
20.             Thread.CurrentThread.IsBackground = false;  
21.             int c;  
22.   
23.             lock (mylock)  
24.             {  
25.                 i++;  
26.                 c = i;  
27.             }  
28.   
29.             if (c == 80)  
30.             {  
31.                 timer.Dispose();//执行Dispose后Timer就不会再申请新的线程了,但是还是会给Timmer已经激发的事件申请线程  
32.                 sw.Stop();  
33.             }  
34.   
35.             if (c < 80)  
36.                 Console.WriteLine("Now:" + c.ToString());  
37.             else  
38.             {  
39.                 Console.WriteLine("Now:" + c.ToString()+"-----------Timer已经Dispose耗时:"+sw.ElapsedMilliseconds.ToString()+"毫秒");  
40.             }  
41.   
42.             if (flag)  
43.             {  
44.                 Thread.Sleep(sleep);//模拟花时间的代码  
45.             }  
46.             else  
47.             {  
48.                 if(i<=80)  
49.                     Thread.Sleep(sleep);//前80次模拟花时间的代码  
50.             }  
51.         }  
52.   
53.         public static void Init(int p_sleep,bool p_flag)  
54.         {  
55.             sleep = p_sleep;  
56.             flag = p_flag;  
57.             timer = new System.Threading.Timer(Excute, null, 0, 10);  
58.         }  
59.     }  
60.   
61.     class SafeTimer  
62.     {  
63.         static int i = 0;  
64.         static System.Threading.Timer timer;  
65.   
66.         static bool flag = true;  
67.         static object mylock = new object();  
68.   
69.         static void Excute(object obj)  
70.         {  
71.             Thread.CurrentThread.IsBackground = false;  
72.   
73.             lock (mylock)  
74.             {  
75.                 if (!flag)  
76.                 {  
77.                     return;  
78.                 }  
79.   
80.                 i++;  
81.   
82.                 if (i == 80)  
83.                 {  
84.                     timer.Dispose();  
85.                     flag = false;  
86.                 }  
87.                 Console.WriteLine("Now:" + i.ToString());  
88.             }  
89.   
90.             Thread.Sleep(1000);//模拟花时间的代码  
91.         }  
92.   
93.         public static void Init()  
94.         {  
95.             timer = new System.Threading.Timer(Excute, null, 0, 10);  
96.         }  
97.     }  
98.   
99.     class Program  
100.     {  
101.         static void Main(string[] args)  
102.         {  
103.             Console.Write("是否使用安全方法(Y/N)?");  
104.             string key = Console.ReadLine();  
105.             if (key.ToLower() == "y")  
106.                 SafeTimer.Init();  
107.             else  
108.             {  
109.                 Console.Write("请输入Timmer响应事件的等待时间(毫秒):");//这个时间直接决定了前80个任务的执行时间，因为等待时间越短，每个任务就可以越快执行完，那么80个任务中就有越多的任务可以用到前面任务执行完后释放掉的线程，也就有越多的任务不必去线程池申请新的线程避免多等待半秒钟的申请时间  
110.                 string sleep = Console.ReadLine();  
111.                 Console.Write("申请了80个线程后Timer剩余激发的线程请求是否需要等待时间(Y/N)?");//这里可以发现选Y或者N只要等待时间不变，最终Timer激发线程的次数都相近，说明Timer的确在执行80次的Dispose后就不再激发新的线程了  
112.                 key = Console.ReadLine();  
113.                 bool flag = false;  
114.                 if (key.ToLower() == "y")  
115.                 {  
116.                     flag = true;  
117.                 }  
118.   
119.                 UnSafeTimer.sw.Start();  
120.                 UnSafeTimer.Init(Convert.ToInt32(sleep), flag);  
121.             }  
122.   
123.             Console.ReadLine();  
124.         }  
125.     }  
126. }  

 

 

这个例子包含了两个Timer的类UnSafeTimer和SafeTimer，两个类的代码的大致意思就是使用Timer每隔10毫秒就执行Excute函数，Excute函数会显示当前执行的次数，在80次的时候通过timer.Dispose()让Timer停止不再激发响应事件。

首先我们来分析下UnSafeTimer

class UnSafeTimer
{
    static int i = 0;
    static System.Threading.Timer timer;
    static object mylock = new object();
    static int sleep;
    static bool flag;
    public static Stopwatch sw = new Stopwatch();

    static void Excute(object obj)
    {
        Thread.CurrentThread.IsBackground = false;
        int c;

        lock (mylock)
        {
            i++;
            c = i;
        }

        if (c == 80)
        {
            timer.Dispose();//执行Dispose后Timer就不会再申请新的线程了,但是还是会给Timmer已经激发的事件申请线程
            sw.Stop();
        }

        if (c < 80)
            Console.WriteLine("Now:" + c.ToString());
        else
        {
            Console.WriteLine("Now:" + c.ToString() + "-----------Timer已经Dispose耗时:" + sw.ElapsedMilliseconds.ToString() + "毫秒");
        }

        if (flag)
        {
            Thread.Sleep(sleep);//模拟花时间的代码
        }
        else
        {
            if (i <= 80)
                Thread.Sleep(sleep);//前80次模拟花时间的代码
        }
    }

    public static void Init(int p_sleep, bool p_flag)
    {
        sleep = p_sleep;
        flag = p_flag;
        timer = new System.Threading.Timer(Excute, null, 0, 10);
    }
}

你可以执行试一试，在输入是否执行安全方法的时候选N，等待时间1000，申请了80个线程后Timer剩余激发的线程选N，本来想在80次的时候停下来，可是你会发现直到执行到660多次之后才停下来（具体看机器配置），申请前80个线程的时间为10532毫秒，反正执行的次数大大超出了限制的80次，回头想想让Timer不在激发事件的方法是调用timer.Dispose()，难不成是Dispose有延迟？延迟的过程中多执行了500多次？那么我们再来做个试验，我们在申请了80个线程后Timer剩余激发的线程选y，请耐心等待结果，在最后你会发现执行时间还是660次左右，这很显然是不合理的，如果Dispose有延迟时间造成所执行500多次，那么加长80次后面每个线程的申请时间在相同的延迟时间内申请的线程数应该减少，因为后面500多个线程每个线程都要执行1000毫秒，那么势必有些线程会去申请新的线程有半秒钟的等待时间（你会发现申请了80个线程后Timer剩余激发的线程选y明显比选n慢得多，就是因为这个原因），所以看来不是因为Dispose造成的。

 

那么会是什么呢？我们这次这样选在输入是否执行安全方法的时候选N，等待时间500，申请了80个线程后Timer剩余激发的线程选N

 

那么会是什么呢？我们这次这样选在输入是否执行安全方法的时候选N，等待时间50，申请了80个线程后Timer剩余激发的线程选N

我们发现随着每次任务等待时间的减少多执行的次数也在减少，最关键的一点我们从图中可以看到，前80次任务申请的时间也在减少，这是最关键的，根据上面线程池所讲的内容我们可以归纳出：每次任务的等待时间直接决定了前80个任务的执行时间，因为等待时间越短，每个任务就可以越快执行完，那么80个任务中就有越多的任务可以用到前面任务执行完后释放掉的线程，也就有越多的任务不必去线程池申请新的线程避免多等待半秒钟的申请时间，而Timer并不会去关心线程池申请前80个任务的时间长短，只要它没有执行到timer.Dispose(),它就会每隔10毫秒激发一次响应时间，不管前80次任务执行时间是长还是短，timer都在第80次任务才执行Dispose，执行Dispose后timer就不会激发新的事件了，但是如果前80次任务申请的时间越长，那么timer就会在前80次任务申请的时间内激发越多响应事件，那么线程池中等待队列中就会有越多的响应函数等待申请线程，System.Threading.Timer没有机制取消线程池等待队列中多余的申请数，所以导致等待时间越长，80次后执行的任务数越多。

 

由此只用timer.Dispose()来终止Timer激发事件是不安全的，所以又写了个安全的执行机制：

 

class SafeTimer
{
    static int i = 0;
    static System.Threading.Timer timer;

    static bool flag = true;
    static object mylock = new object();

    static void Excute(object obj)
    {
        Thread.CurrentThread.IsBackground = false;

        lock (mylock)
        {
            if (!flag)
            {
                return;
            }

            i++;

            if (i == 80)
            {
                timer.Dispose();
                flag = false;
            }
            Console.WriteLine("Now:" + i.ToString());
        }

        Thread.Sleep(1000);//模拟花时间的代码
    }

    public static void Init()
    {
        timer = new System.Threading.Timer(Excute, null, 0, 10);
    }
}

安全类中我们用了个bool类型的变量flag来判断当前是否执行到80次了，执行到80次后将flag置为false，然后timer.Dispose，这时虽然任务还是要多执行很多次但是由于flag为false，Excute函数一开始就做了判断flag为false会立即退出，Excute函数80次后相当于就不执行了。

 

 

 

 

3、System.Timers.Timer

在上面的例子中我们看到System.Threading.Timer很不安全，即使在安全的方法类，也只能让事件响应函数在80次后立刻退出让其执行时间近似于0，但是还是浪费了系统不少的资源。

所以本人更推荐使用现在介绍的System.Timers.Timer,System.Timers.Timer大致原理和System.Threading.Timer差不多，唯一几处不同的就是：

• 构造函数不同，构造函数可以什么事情也不做，也可以传入响应间隔时间：System.Timers.Timer timer = new System.Timers.Timer(10);
• 响应事件的响应函数不在构造函数中设置：timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
• 声明System.Timers.Timer对象后他不会自动执行，需要调用 timer.Start()或者timer.Enabled = true来启动它， timer.Start()的内部原理还是设置timer.Enabled = true
• 调用 timer.Stop()或者timer.Enabled = false来停止引发Elapsed事件， timer.Stop()的内部原理还是设置timer.Enabled = false，最重要的是timer.Enabled = false后会取消线程池中当前等待队列中剩余任务的执行。

那么我们来看个例子:

[c-sharp] view plaincopy

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Timers;  
6. using System.Threading;  
7.   
8. namespace ConsoleApplication2  
9. {  
10.     class UnSafeTimer  
11.     {  
12.         static int i = 0;  
13.         static System.Timers.Timer timer;  
14.         static object mylock = new object();  
15.   
16.         public static void Init()  
17.         {  
18.             timer = new System.Timers.Timer(10);  
19.             timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);  
20.             timer.Start();  
21.         }  
22.   
23.         static void timer_Elapsed(object sender, ElapsedEventArgs e)  
24.         {  
25.             Thread.CurrentThread.IsBackground = false;  
26.             int c;  
27.   
28.             lock (mylock)  
29.             {  
30.                 i++;  
31.                 c = i;  
32.             }  
33.   
34.             Console.WriteLine("Now:" + i.ToString());  
35.   
36.             if (c == 80)  
37.             {  
38.                 timer.Stop();//可应看到System.Timers.Timer的叫停机制比System.Threading.Timer好得多，就算在不安全的代码下Timer也最多多执行一两次（我在试验中发现有时会执行到81或82），说明Stop方法在设置Timer的Enable为false后不仅让Timer不再激发响应事件，还取消了线程池等待队列中等待获得线程的任务，至于那多执行的一两次任务我个人认为是Stop执行过程中会耗费一段时间才将Timer的Enable设置为false，这段时间多余的一两个任务就获得了线程开始执行  
39.             }  
40.   
41.   
42.             Thread.Sleep(1000);//等待1000毫秒模拟花时间的代码，注意：这里的等待时间直接决定了80(由于是不安全模式有时会是81或82、83)个任务的执行时间，因为等待时间越短，每个任务就可以越快执行完，那么80个任务中就有越多的任务可以用到前面任务执行完后释放掉的线程，也就有越多的任务不必去线程池申请新的线程避免多等待半秒钟的申请时间  
43.         }  
44.     }  
45.   
46.     class SafeTimer  
47.     {  
48.         static int i = 0;  
49.         static System.Timers.Timer timer;  
50.   
51.         static bool flag = true;  
52.         static object mylock = new object();  
53.   
54.         public static void Init()  
55.         {  
56.             timer = new System.Timers.Timer(10);  
57.             timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);  
58.             timer.Start();   
59.         }  
60.   
61.         static void timer_Elapsed(object sender, ElapsedEventArgs e)  
62.         {  
63.             Thread.CurrentThread.IsBackground = false;  
64.   
65.             lock (mylock)  
66.             {  
67.                 if (!flag)  
68.                 {  
69.                     return;  
70.                 }  
71.                 i++;  
72.   
73.                 Console.WriteLine("Now:" + i.ToString());  
74.   
75.                 if (i == 80)  
76.                 {  
77.                     timer.Stop();  
78.                     flag = false;  
79.                 }  
80.             }  
81.   
82.             Thread.Sleep(1000);//同UnSafeTimer  
83.         }  
84.   
85.         class Program  
86.         {  
87.             static void Main(string[] args)  
88.             {  
89.                 Console.Write("是否使用安全Timer>(Y/N)?");  
90.                 string Key = Console.ReadLine();  
91.   
92.                 if (Key.ToLower() == "y")  
93.                     SafeTimer.Init();  
94.                 else  
95.                     UnSafeTimer.Init();  
96.   
97.                 Console.ReadLine();  
98.             }  
99.         }  
100.     }  
101. }  

 这个例子和System.Threading.Timer差不多，这里也分为:安全类SafeTimer和不安全类UnSafeTimer,原因是 timer.Stop()有少许的延迟时间有时任务会执行到81~83，但是就算是不安全方法也就最多多执行几次，不像System.Threading.Timer多执行上百次...

所以我这里还是推荐大家使用System.Timers.Timer