c#.net 多线程编程学习（3）

Case 学习多线程

在前面的多线程编程系列的文章中，我们了解了在.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);
}
}

　　最后运行的结果如下：

　　通过上面的运行结果，我们可以明显的看出运行结果并不是我们所期望的那样，开始的两个结果，读线程运行在写线程之前，这是我们极力要避免发生的事情。

下面我将使用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，换一句话说就是等待他们完成了各自的任务。