.NET多线程编程（2）

// define the dueTime and period

long dTime = 20 ;       // wait before the first tick (in ms)

long pTime = 150 ;     // timer during subsequent invocations (in ms)

 

       // instantiate the Timer object

Timer atimer = new Timer(tcallback, null, dTime, pTime) ;

 

// do some thing with the timer object

    ...

//change the dueTime and period of the Timer

dTime=100;

pTime=300;

atimer.Change(dTime, pTime) ;

// do some thing

    ...

atimer.Dispose() ;      

    ...

}

 

异步编程

 

这部分内容如果要讲清楚本来就是很大的一部分,在这里,我不打算详细讨论这个东西,我们只是需要直到它是什么,因为多线程编程如果忽律异步的多线程编程显然是不应该的。异步的多线程编程是你的程序可能会用到的另外一种多线程编程方法。

在前面的文章我们花了很大的篇幅来介绍线程的同步和怎么实现线程的同步,但是它有一个固有的致命的缺点,你或许注意到了这一点。那就是每个线程必须作同步调用,也就是等到其他的功能完成,否则就阻塞。当然,某些情况下,对于那些逻辑上相互依赖的任务来说是足够的。异步编程允许更加复杂的灵活性。一个线程可以作异步调用,不需要等待其他的东西。你可以使用这些线程作任何的任务,线程负责获取结果推进运行。这给予了那些需要管理数目巨大的请求而且负担不起请求等待代价的企业级的系统更好的可伸缩性。

.NET平台提供了一致的异步编程机制用于ASP.NET,I/O,Web Services,Networking,Message等。

 

后记

由于学习的时候很难找到中文这方面的资料，因此我就只好学习英文的资料，由于水平不高，翻译的时候可能难免曲解原文的意思，希望大家能够指出，同时希望这些东西能够给大家在学习这方面知识给予一定的参考和帮助，那怕是一点点，就很欣慰了。

    

NET多线程编程(5)：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);

        }

}

最后运行的结果如下：

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

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