C#的多线程机制探索二

首先，我们定义一个被操作的对象的类Cell，在这个类里，有两个方法：ReadFromCell()和WriteToCell。消费者线程将调用ReadFromCell()读取cellContents的内容并且显示出来，生产者进程将调用WriteToCell()方法向cellContents写入数据。

　　public class Cell
　　{
　　int cellContents; // Cell对象里边的内容
　　bool readerFlag = false; // 状态标志，为true时可以读取，为false则正在写入
　　public int ReadFromCell( )
　　{
　　　　lock(this) // Lock关键字保证了什么，请大家看前面对lock的介绍
　　　　{
　　　　if (!readerFlag)//如果现在不可读取
　　　　{
　　　　　　try
　　　　　　{
　　　　　　file://等待WriteToCell方法中调用Monitor.Pulse()方法
　　　　　　Monitor.Wait(this);
　　　　　　}
　　　　　　catch (SynchronizationLockException e)
　　　　　　{
　　　　　　Console.WriteLine(e);
　　　　　　}
　　　　　　catch (ThreadInterruptedException e)
　　　　　　{
　　　　　　Console.WriteLine(e);
　　　　　　}
　　　　}
　　　　Console.WriteLine("Consume: {0}",cellContents);
　　　　readerFlag = false; file://重置readerFlag标志，表示消费行为已经完成
　　　　Monitor.Pulse(this); file://通知WriteToCell()方法（该方法在另外一个线程中执行，等待中）
　　　　}
　　　　return cellContents;
　　}

　　public void WriteToCell(int n)
　　{
　　　　lock(this)
　　　　{
　　　　if (readerFlag)
　　　　{
　　　　　　try
　　　　　　{
　　　　　　Monitor.Wait(this);
　　　　　　}
　　　　　　catch (SynchronizationLockException e)
　　　　　　{
　　　　　　file://当同步方法（指Monitor类除Enter之外的方法）在非同步的代码区被调用
　　　　　　Console.WriteLine(e);
　　　　　　}
　　　　　　catch (ThreadInterruptedException e)
　　　　　　{
　　　　　　file://当线程在等待状态的时候中止
　　　　　　Console.WriteLine(e);
　　　　　　}
　　　　}
　　　　cellContents = n;
　　　　Console.WriteLine("Produce: {0}",cellContents);
　　　　readerFlag = true;
　　　　Monitor.Pulse(this); file://通知另外一个线程中正在等待的ReadFromCell()方法
　　　　}
　　}
　　}

　　下面定义生产者CellProd和消费者类CellCons，它们都只有一个方法ThreadRun()，以便在Main()函数中提供给线程的ThreadStart代理对象，作为线程的入口。

　　public class CellProd
　　{
　　Cell cell; // 被操作的Cell对象
　　int quantity = 1; // 生产者生产次数，初始化为1

　　public CellProd(Cell box, int request)
　　{
　　　　//构造函数
　　　　cell = box;
　　　　quantity = request;
　　}
　　public void ThreadRun( )
　　{
　　　　for(int looper=1; looper<=quantity; looper++)
　　　　cell.WriteToCell(looper); file://生产者向操作对象写入信息
　　}
　　}

　　public class CellCons
　　{
　　Cell cell;
　　int quantity = 1;

　　public CellCons(Cell box, int request)
　　{
　　　　cell = box;
　　　　quantity = request;
　　}
　　public void ThreadRun( )
　　{
　　　　int valReturned;
　　　　for(int looper=1; looper<=quantity; looper++)
　　　　valReturned=cell.ReadFromCell( );//消费者从操作对象中读取信息
　　}
　　}

然后在下面这个类MonitorSample的Main()函数中我们要做的就是创建两个线程分别作为生产者和消费者，使用CellProd.ThreadRun()方法和CellCons.ThreadRun()方法对同一个Cell对象进行操作。

　　public class MonitorSample
　　{
　　public static void Main(String[] args)
　　{
　　　　int result = 0; file://一个标志位，如果是0表示程序没有出错，如果是1表明有错误发生
　　　　Cell cell = new Cell( );

　　　　//下面使用cell初始化CellProd和CellCons两个类，生产和消费次数均为20次
　　　　CellProd prod = new CellProd(cell, 20);
　　　　CellCons cons = new CellCons(cell, 20);

　　　　Thread producer = new Thread(new ThreadStart(prod.ThreadRun));
　　　　Thread consumer = new Thread(new ThreadStart(cons.ThreadRun));
　　　　//生产者线程和消费者线程都已经被创建，但是没有开始执行

　　　　try
　　　　{
　　　　producer.Start( );
　　　　consumer.Start( );

　　　　producer.Join( );
　　　　consumer.Join( );
　　　　Console.ReadLine();
　　　　}
　　　　catch (ThreadStateException e)
　　　　{
　　　　file://当线程因为所处状态的原因而不能执行被请求的操作
　　　　Console.WriteLine(e);
　　　　result = 1;
　　　　}
　　　　catch (ThreadInterruptedException e)
　　　　{
　　　　file://当线程在等待状态的时候中止
　　　　Console.WriteLine(e);
　　　　result = 1;
　　　　}
　　　　//尽管Main()函数没有返回值，但下面这条语句可以向父进程返回执行结果
　　　　Environment.ExitCode = result;
　　}
　　}

大家可以看到，在上面的例程中，同步是通过等待Monitor.Pulse()来完成的。首先生产者生产了一个值，而同一时刻消费者处于等待状态，直到收到生产者的“脉冲(Pulse)”通知它生产已经完成，此后消费者进入消费状态，而生产者开始等待消费者完成操作后将调用Monitor.Pulese()发出的“脉冲”。它的执行结果很简单：

　　Produce: 1
　　Consume: 1
　　Produce: 2
　　Consume: 2
　　Produce: 3
　　Consume: 3
　　...
　　...
　　Produce: 20
　　Consume: 20

　　事实上，这个简单的例子已经帮助我们解决了多线程应用程序中可能出现的大问题，只要领悟了解决线程间冲突的基本方法，很容易把它应用到比较复杂的程序中去。

　　四、线程池和定时器——多线程的自动管理
　　在多线程的程序中，经常会出现两种情况。一种情况下，应用程序中的线程把大部分的时间花费在等待状态，等待某个事件发生，然后才能给予响应；而另外一种情况则是线程平常都处于休眠状态，只是周期性地被唤醒。在.net framework里边，我们使用ThreadPool来对付第一种情况，使用Timer来对付第二种情况。

　　ThreadPool类提供一个由系统维护的线程池——可以看作一个线程的容器，该容器需要Windows 2000以上版本的系统支持，因为其中某些方法调用了只有高版本的Windows才有的API函数。你可以使用ThreadPool.QueueUserWorkItem()方法将线程安放在线程池里，该方法的原型如下：

　　//将一个线程放进线程池，该线程的Start()方法将调用WaitCallback代理对象代表的函数
　　public static bool QueueUserWorkItem(WaitCallback);
　　//重载的方法如下，参数object将传递给WaitCallback所代表的方法
　　public static bool QueueUserWorkItem(WaitCallback, object);


　　要注意的是，ThreadPool类也是一个静态类，你不能也不必要生成它的对象，而且一旦使用该方法在线程池中添加了一个项目，那么该项目将是没有办法取消的。在这里你无需自己建立线程，只需把你要做的工作写成函数，然后作为参数传递给ThreadPool.QueueUserWorkItem()方法就行了，传递的方法就是依靠WaitCallback代理对象，而线程的建立、管理、运行等等工作都是由系统自动完成的，你无须考虑那些复杂的细节问题，线程池的优点也就在这里体现出来了，就好像你是公司老板——只需要安排工作，而不必亲自动手。

下面的例程演示了ThreadPool的用法。首先程序创建了一个ManualResetEvent对象，该对象就像一个信号灯，可以利用它的信号来通知其它线程，本例中当线程池中所有线程工作都完成以后，ManualResetEvent的对象将被设置为有信号，从而通知主线程继续运行。它有几个重要的方法：Reset()，Set()，WaitOne()。初始化该对象时，用户可以指定其默认的状态（有信号/无信号），在初始化以后，该对象将保持原来的状态不变直到它的Reset()或者Set()方法被调用，Reset()方法将其设置为无信号状态，Set()方法将其设置为有信号状态。WaitOne()方法使当前线程挂起直到ManualResetEvent对象处于有信号状态，此时该线程将被激活。然后，程序将向线程池中添加工作项，这些以函数形式提供的工作项被系统用来初始化自动建立的线程。当所有的线程都运行完了以后，ManualResetEvent.Set()方法被调用，因为调用了ManualResetEvent.WaitOne()方法而处在等待状态的主线程将接收到这个信号，于是它接着往下执行，完成后边的工作。

　　using System;
　　using System.Collections;
　　using System.Threading;

　　//这是用来保存信息的数据结构，将作为参数被传递
　　public class SomeState
　　{
　　public int Cookie;
　　public SomeState(int iCookie)
　　{
　　　　Cookie = iCookie;
　　}
　　}

　　public class Alpha
　　{
　　public Hashtable HashCount;
　　public ManualResetEvent eventX;
　　public static int iCount = 0;
　　public static int iMaxCount = 0;
　　public Alpha(int MaxCount)
　　{
　　　　HashCount = new Hashtable(MaxCount);
　　　　iMaxCount = MaxCount;
　　}

　　file://线程池里的线程将调用Beta()方法
　　public void Beta(Object state)
　　{
　　　　//输出当前线程的hash编码值和Cookie的值
　　　　Console.WriteLine(" {0} {1} :", Thread.CurrentThread.GetHashCode(),
　　　　((SomeState)state).Cookie);
　　　　Console.WriteLine("HashCount.Count=={0}, Thread.CurrentThread.GetHashCode()=={1}", HashCount.Count, Thread.CurrentThread.GetHashCode());
　　　　lock (HashCount)
　　　　{
　　　　file://如果当前的Hash表中没有当前线程的Hash值，则添加之
　　　　if (!HashCount.ContainsKey(Thread.CurrentThread.GetHashCode()))
　　　　　　HashCount.Add (Thread.CurrentThread.GetHashCode(), 0);
　　　　HashCount[Thread.CurrentThread.GetHashCode()] =
((int)HashCount[Thread.CurrentThread.GetHashCode()])+1;
　　　　}

　　　　int iX = 2000;
　　　　Thread.Sleep(iX);
　　　　//Interlocked.Increment()操作是一个原子操作，具体请看下面说明
　　　　Interlocked.Increment(ref iCount);
　　　　if (iCount == iMaxCount)
　　　　{
　　　　Console.WriteLine();
　　　　Console.WriteLine("Setting eventX ");
　　　　eventX.Set();
　　　　}
　　}
　　}

　　public class SimplePool
　　{
　　public static int Main(string[] args)
　　{
　　　　Console.WriteLine("Thread Pool Sample:");
　　　　bool W2K = false;
　　　　int MaxCount = 10;//允许线程池中运行最多10个线程
　　　　//新建ManualResetEvent对象并且初始化为无信号状态
　　　　ManualResetEvent eventX = new ManualResetEvent(false);
　　　　Console.WriteLine("Queuing {0} items to Thread Pool", MaxCount);
　　　　Alpha oAlpha = new Alpha(MaxCount); file://创建工作项
　　　　//注意初始化oAlpha对象的eventX属性
　　　　oAlpha.eventX = eventX;
　　　　Console.WriteLine("Queue to Thread Pool 0");
　　　　try
　　　　{
　　　　file://将工作项装入线程池
　　　　file://这里要用到Windows 2000以上版本才有的API，所以可能出现NotSupportException异常
　　　　ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta),
　　　　new SomeState(0));
　　　　W2K = true;
　　　　}
　　　　catch (NotSupportedException)
　　　　{
　　　　Console.WriteLine("These API's may fail when called on a non-Windows 2000 system.");
　　　　W2K = false;
　　　　}
　　　　if (W2K)//如果当前系统支持ThreadPool的方法.
　　　　{
　　　　for (int iItem=1;iItem < MaxCount;iItem++)
　　　　{
　　　　　　//插入队列元素
　　　　　　Console.WriteLine("Queue to Thread Pool {0}", iItem);
　　　　　　ThreadPool.QueueUserWorkItem(new WaitCallback(oAlpha.Beta),new SomeState(iItem));
　　　　}
　　　　Console.WriteLine("Waiting for Thread Pool to drain");
　　　　file://等待事件的完成，即线程调用ManualResetEvent.Set()方法
　　　　eventX.WaitOne(Timeout.Infinite,true);
　　　　file://WaitOne()方法使调用它的线程等待直到eventX.Set()方法被调用
　　　　Console.WriteLine("Thread Pool has been drained (Event fired)");
　　　　Console.WriteLine();
　　　　Console.WriteLine("Load across threads");
　　　　foreach(object o in oAlpha.HashCount.Keys)
　　　　Console.WriteLine("{0} {1}", o, oAlpha.HashCount[o]);
　　　　}
　　　　Console.ReadLine();
　　　　return 0;

　　}
　　}

　　程序中有些小地方应该引起我们的注意。SomeState类是一个保存信息的数据结构，在上面的程序中，它作为参数被传递给每一个线程，你很容易就能理解这个，因为你需要把一些有用的信息封装起来提供给线程，而这种方式是非常有效的。程序出现的InterLocked类也是专为多线程程序而存在的，它提供了一些有用的原子操作，所谓原子操作就是在多线程程序中，如果这个线程调用这个操作修改一个变量，那么其他线程就不能修改这个变量了，这跟lock关键字在本质上是一样的。

　　我们应该彻底地分析上面的程序，把握住线程池的本质，理解它存在的意义是什么，这样我们才能得心应手地使用它。下面是该程序的输出结果：