.NET多线程编程（5）——案例学习多线程

    在前面的多线程编程系列的文章中，咱们了解了在.NET中多线程编程必需要掌握的基本知识，可是可能你们看了文章以后，感受仍是很模糊，对一个具体的编程可能仍是以为无从下手，究其缘由多是理论讲的过多，而没有太多的实际参考例子，形成收获不大。所以，在接下来的文章中，我将给出几个典型的多线程编程的实例，让你们有更清楚的认识。

Case 1 - No synchronization

　　在咱们的第一个例子中，有两类线程，两个是读线程，一个是写线程，两个线程是并行运行的而且须要访问同一个共享资源。读线程在写线程以前启动，用于设置共享变量的值。我使用Thread.Sleep来完成这些工做。摘录代码以下：

Thread t0 = new Thread(new ThreadStart(WriteThread));

Thread t1 = new Thread(new ThreadStart(ReadThread10));

Thread t2 = new Thread(new ThreadStart(ReadThread20));

t0.IsBackground=true;

t1.IsBackground=true;

t2.IsBackground=true;

t0.Start();

t1.Start();

t2.Start();

　　正如所看到的那样，读线程启动以后当即启动两个写线程。下面的代码是两个读线程和写线程所执行的代码。

public void WriteThread()
{
Thread.Sleep(1000);
m_x=3;
}
public void ReadThread10()
{
int a = 10;
for(int y=0;y<5;y++)
{
string s = "ReadThread10";
s = s + " # multiplier= ";
s = s + Convert.ToString(a) + " # ";
s = s + a * m_x;
listBox1.Items.Add(s);
Thread.Sleep(1000);
}
}
public void ReadThread20()
{
int a = 20;
for(int y=0;y<5;y++)
{
string s = "ReadThread20";
s = s + " # multiplier= ";
s = s + Convert.ToString(a) + " # ";
s = s + a * m_x;
listBox1.Items.Add(s);
Thread.Sleep(1000);
}
}

　　最后运行的结果以下：

　　经过上面的运行结果，咱们能够明显的看出运行结果并非咱们所指望的那样，开始的两个结果，读线程运行在写线程以前，这是咱们极力要避免发生的事情。

Case 2 - Synchronization [One WriteThread - Many ReadThreads]

下面我将使用ManualResetEvent来解决上面遇到的问题来达到线成的同步，惟一不一样的是咱们在启动读线程和写线程以前使用安全的方法。

Thread t0 = new Thread(new ThreadStart(SafeWriteThread));

Thread t1 = new Thread(new ThreadStart(SafeReadThread10));

Thread t2 = new Thread(new ThreadStart(SafeReadThread20));

t0.IsBackground=true;

t1.IsBackground=true;

t2.IsBackground=true;

t0.Start();

t1.Start();

t2.Start();

　　添加一个ManualResetEvent：

m_mre = new ManualResetEvent(false);

　　看看SafeWriteThread的代码：

public void SafeWriteThread()
{
m_mre.Reset();
WriteThread();
m_mre.Set();
}

　　Reset设置ManualResetEvent的状态为non-signaled，这意味着事件没有发生。接着咱们来调用WriteThread方法，实际上能够跳过Reset这一步，由于咱们在ManualResetEvent的构造函数设置其状态为non-signaled。一旦WriteThread线程返回，调用Set方法设置ManualResetEvent的状态为signaled。

　　下面让咱们来看看另外两个SafeReadThread方法：

public void SafeReadThread10()
{
m_mre.WaitOne();
ReadThread10();
}
public void SafeReadThread20()
{
m_mre.WaitOne();
ReadThread20();
}

　　WaitOne方法将阻塞当前的线程直到ManualResetEvent的状态被设置为signaled。在这里，咱们程序中的两个读线程都将阻塞至SafeWriteThread完成任务后调用Set方法。这样咱们就确保了两个读线程在写线程完成对共享资源的访问以后才执行。


Case 3 - Synchronization [Many WriteThreads - Many ReadThreads]

　　下面咱们将模拟更为复杂的情形。在下面的程序中，有多个写线程和读线程。读线程只有在全部的写线程完成了任务以后才能访问共享资源。在实际的状况中，读线程多是并行的运行，可是为了简便起见，我使写线程运行有必定的顺序，只有在前一个写线程完成以后，第二个写线程才能启动。

在这里，我增长了一个ManualResetEvent对象和ManualResetEvent的数组。

public ManualResetEvent m_mreB;

public ManualResetEvent[] m_mre_array;

　　添加初始化代码：

m_mreB = new ManualResetEvent(false);

m_mre_array = new ManualResetEvent[2];

m_mre_array[0]=m_mre;

m_mre_array[1]=m_mreB;

　　启动四个线程：

Thread t0 = new Thread(new ThreadStart(SafeWriteThread));

Thread t0B = new Thread(new ThreadStart(SafeWriteThreadB));

Thread t1 = new Thread(new ThreadStart(SafeReadThread10B));

Thread t2 = new Thread(new ThreadStart(SafeReadThread20B));

t0.IsBackground=true;

t0B.IsBackground=true;

t1.IsBackground=true;

t2.IsBackground=true;

t0.Start();

t0B.Start();

t1.Start();

t2.Start();

　　在这里有两个StartThreads和两个WriteThreads，让咱们看看他们的执行：

public void SafeWriteThread()

{
m_mre.Reset();

WriteThread();

m_mre.Set();
}

public void SafeWriteThreadB()

{
m_mreB.Reset();

m_mre.WaitOne();

Thread.Sleep(1000);

m_x+=3;

m_mreB.Set();
}

　　我对第二个WriteThread使用了另一个事件对象，为了模拟等待第一个线程完成工做。

public void SafeReadThread10B()

{
WaitHandle.WaitAll(m_mre_array);

ReadThread10();
}

public void SafeReadThread20B()

{
WaitHandle.WaitAll(m_mre_array);

ReadThread20();
}

　　在这里，使用了一个WaitAll的方法，他是WaitHandle基类提供给ManualResetEvent的静态方法，它的参数为咱们在前面定义的ManualResetEvent数组。他阻塞当前的线程直到参数数组里面全部的ManualResetEvent对象设置状态为signaled，换一句话说就是等待他们完成了各自的任务。