多线程进阶代码三

1. // @ 来源于挽留刀的技术系列文章-C#的多线程机制探索
2. using System;
3. using System.Collections.Generic;
4. using System.Linq;
5. using System.Text;
6. using System.Collections;
7. using System.Threading;
9. namespace MutiThread
10. {
11.     /* 在多线程的程序中，经常会出现两种情况。一种情况下，应用程序中的线程
12.      * 把大部分的时间花费在等待状态，等待某个事件发生，然后才能给予响应；
13.      * 而另外一种情况则是线程平常都处于休眠状态，只是周期性地被唤醒。
14.      * 在.net framework里边，我们使用ThreadPool来对付第一种情况，使用Timer
15.      * 来对付第二种情况。本例就是ThreadPool的实例，Timer的实例参看Program4*/
17.     /* ThreadPool类也是一个静态类,你无需自己建立线程，只需把你要做的工作写
18.      * 成函数，然后作为参数传递给ThreadPool.QueueUserWorkItem()方法就行了，
19.      * 传递的方法就是依靠WaitCallback代理对象，而线程的建立、管理、运行等等
20.      * 工作都是由系统自动完成的，你无须考虑那些复杂的细节问题
21.      * 就好像你是公司老板——只需要安排工作，而不必亲自动手。*/
23.     //这是用来保存信息的数据结构，将作为参数被传递
24.     public class SomeState
25.     {
26.         public int Cookie;
27.         public SomeState(int iCookie)
28.         {
29.             Cookie = iCookie;
30.         }
31.     }
33.     public class Alpha
34.     {
35.         public Hashtable HashCount;
36.         // ManualResetEvent允许线程通过发信号互相通信,此通信涉及一个线程在其他线程进行之前必须完成的任务,相当于一个信号灯，可以利用它的信号来通知其它线程.
37.         public ManualResetEvent eventX;
38.         public static int iCount = 0;
39.         public static int iMaxCount = 0;
40.         public Alpha(int MaxCount)
41.         {
42.             HashCount = new Hashtable(MaxCount);
43.             iMaxCount = MaxCount;
44.         }
46.         // 线程池里的线程将调用Beta()方法
47.         public void Beta(Object state)
48.         {
49.             // 输出当前线程的hash编码值和Cookie的值
50.             Console.WriteLine(" {0} {1} :", Thread.CurrentThread.GetHashCode(), ((SomeState)state).Cookie);
52.             Console.WriteLine("HashCount.Count=={0}, Thread.CurrentThread.GetHashCode()=={1}", HashCount.Count, Thread.CurrentThread.GetHashCode());
54.             lock (HashCount)
55.             {
56.                 // 如果当前的Hash表中没有当前线程的Hash值，则添加之
57.                 if (!HashCount.ContainsKey(Thread.CurrentThread.GetHashCode()))
58.                 {
59.                     HashCount.Add(Thread.CurrentThread.GetHashCode(), 0);
60.                 }
61.                 HashCount[Thread.CurrentThread.GetHashCode()] = ((int)HashCount[Thread.CurrentThread.GetHashCode()]) + 1;
62.             }
64.             // 将当前线程挂起指定的时间
65.             int iX = 2000;
66.             Thread.Sleep(iX);
68.             /* Interlocked类为多个线程共享的变量提供原子操作，因为增加变量操作不
69.              * 是一个原子操作，可看成三个步骤来完成(可在msdn中Interlocked类的内容)，
70.              * 以防当前线程在执行完前两个步骤后而被其他线程抢先 */
71.             // Interlocked.Increment()以原子操作的形式递增指定变量的值并存储结果
72.             Interlocked.Increment(ref iCount);
73.             if (iCount == iMaxCount)
74.             {
75.                 Console.WriteLine();
76.                 Console.WriteLine("Setting eventX ");
77.                 // Set()将事件状态设置为终止状态，允许等待线程继续；Reset()将事件状态设置为非终止状态，从而导致等待线程线程受阻 
78.                 eventX.Set();
79.             }
80.         }
81.     }
83.     public class SimplePool
84.     {
85.         public static int Main(string[] args)
86.         {
87.             Console.WriteLine("Thread Pool Sample:");
88.             bool W2K = false;
89.             int MaxCount = 10;// 允许线程池中运行最多10个线程
90.             // 新建ManualResetEvent对象并且初始化为无信号状态
91.             ManualResetEvent eventX = new ManualResetEvent(false);
92.             Console.WriteLine("Queuing {0} items to Thread Pool", MaxCount);
93.             Alpha oAlpha = new Alpha(MaxCount); // 创建工作项
94.             // 注意初始化oAlpha对象的eventX属性
95.             oAlpha.eventX = eventX;
96.             Console.WriteLine("Queue to Thread Pool 0");
97.             try
98.             {
99.                 // 将工作项装入线程池 
100.                 // 这里要用到Windows 2000以上版本才有的API，所以可能出现NotSupportException异常
101.                 ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta),
102.                 new SomeState(0));
103.                 W2K = true;
104.             }
105.             catch (NotSupportedException)
106.             {
107.                 Console.WriteLine("These API's may fail when called on a non-Windows 2000 system.");
108.                 W2K = false;
109.             }
110.             if (W2K)// 如果当前系统支持ThreadPool的方法.
111.             {
112.                 for (int iItem = 1; iItem < MaxCount; iItem++)
113.                 {
114.                     // 插入队列元素
115.                     Console.WriteLine("Queue to Thread Pool {0}", iItem);
116.                     ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta), new SomeState(iItem));
117.                 }
118.                 Console.WriteLine("Waiting for Thread Pool to drain");
119.                 // 使当前主线程挂起,等待事件的完成,即线程调用ManualResetEvent.Set()方法
120.                 eventX.WaitOne(Timeout.Infinite, true);
121.                 // WaitOne()方法使调用它的线程等待直到eventX.Set()方法被调用
122.                 Console.WriteLine("Thread Pool has been drained (Event fired)");
123.                 Console.WriteLine();
124.                 Console.WriteLine("Load across threads");
125.                 foreach (object o in oAlpha.HashCount.Keys)
126.                 {
127.                     Console.WriteLine("{0} {1}", o, oAlpha.HashCount[o]);
128.                 }
129.             }
130.             Console.ReadLine();
131.             return 0;
132.         }
133.     }
134. }