C#多线程学习之(六)互斥对象用法实例_c#

本文实例讲述了c#多线程学习之互斥对象用法。分享给大家供大家参考。具体分析如下：

如何控制好多个线程相互之间的联系，不产生冲突和重复，这需要用到互斥对象，即：system.threading 命名空间中的 mutex 类。

我们可以把mutex看作一个出租车，乘客看作线程。乘客首先等车，然后上车，最后下车。当一个乘客在车上时，其他乘客就只有等他下车以后才可以上车。而线程与mutex对象的关系也正是如此，线程使用mutex.waitone()方法等待mutex对象被释放，如果它等待的mutex对象被释放了，它就自动拥有这个对象，直到它调用mutex.releasemutex()方法释放这个对象，而在此期间，其他想要获取这个mutex对象的线程都只有等待。

下面这个例子使用了mutex对象来同步四个线程，主线程等待四个线程的结束，而这四个线程的运行又是与两个mutex对象相关联的。

其中还用到autoresetevent类的对象，可以把它理解为一个信号灯。这里用它的有信号状态来表示一个线程的结束。
autoresetevent.set()方法设置它为有信号状态
autoresetevent.reset()方法设置它为无信号状态

mutex 类的程序示例：

using system;
using system.threading;
namespace threadexample
{
 public class mutexsample
 {
 static mutex gm1;
 static mutex gm2;
 const int iters = 100;
 static autoresetevent event1 = new autoresetevent(false);
 static autoresetevent event2 = new autoresetevent(false);
 static autoresetevent event3 = new autoresetevent(false);
 static autoresetevent event4 = new autoresetevent(false);
 public static void main(string[] args)
 {
 console.writeline("mutex sample ");
 //创建一个mutex对象，并且命名为mymutex
 gm1 = new mutex(true,"mymutex");
 //创建一个未命名的mutex 对象.
 gm2 = new mutex(true);
 console.writeline(" - main owns gm1 and gm2");
 autoresetevent[] evs = new autoresetevent[4];
 evs[0] = event1; //为后面的线程t1,t2,t3,t4定义autoresetevent对象
 evs[1] = event2; 
 evs[2] = event3; 
 evs[3] = event4; 
 mutexsample tm = new mutexsample( );
 thread t1 = new thread(new threadstart(tm.t1start));
 thread t2 = new thread(new threadstart(tm.t2start));
 thread t3 = new thread(new threadstart(tm.t3start));
 thread t4 = new thread(new threadstart(tm.t4start));
 t1.start( );
 //使用mutex.waitall()方法等待一个mutex数组中的对象全部被释放
 t2.start( );
 //使用mutex.waitone()方法等待gm1的释放
 t3.start( );
 //使用mutex.waitany()方法等待一个mutex数组中任意一个对象被释放
 t4.start( );
 //使用mutex.waitone()方法等待gm2的释放
 thread.sleep(2000);
 console.writeline(" - main releases gm1");
 gm1.releasemutex( );
 //线程t2,t3结束条件满足
 thread.sleep(1000);
 console.writeline(" - main releases gm2");
 gm2.releasemutex( );
 //线程t1,t4结束条件满足
 //等待所有四个线程结束
 waithandle.waitall(evs); 
 console.writeline(" mutex sample");
 console.readline();
 }
 public void t1start( )
 {
 console.writeline("t1start started, mutex.waitall(mutex[])");
 mutex[] gms = new mutex[2];
 gms[0] = gm1;
 //创建一个mutex数组作为mutex.waitall()方法的参数
 gms[1] = gm2;
 mutex.waitall(gms);
 //等待gm1和gm2都被释放
 thread.sleep(2000);
 console.writeline("t1start finished,mutex.waitall(mutex[]) satisfied");
 event1.set( );
 //线程结束，将event1设置为有信号状态
 }
 public void t2start( )
 {
 console.writeline("t2start started, gm1.waitone( )");
 gm1.waitone( );//等待gm1的释放
 console.writeline("t2start finished, gm1.waitone( ) satisfied");
 event2.set( );//线程结束，将event2设置为有信号状态
 }
 public void t3start( )
 {
 console.writeline("t3start started, mutex.waitany(mutex[])");
 mutex[] gms = new mutex[2];
 gms[0] = gm1;//创建一个mutex数组作为mutex.waitany()方法的参数
 gms[1] = gm2;
 mutex.waitany(gms);//等待数组中任意一个mutex对象被释放
 console.writeline("t3start finished, mutex.waitany(mutex[])");
 event3.set( );//线程结束，将event3设置为有信号状态
 }
 public void t4start( )
 {
 console.writeline("t4start started, gm2.waitone( )");
 gm2.waitone( );//等待gm2被释放
 console.writeline("t4start finished, gm2.waitone( )");
 event4.set( );//线程结束，将event4设置为有信号状态
 }
 }
}

程序的输出结果：

mutex sample 
 - main owns gm1 and gm2
t1start started, mutex.waitall(mutex[])
t2start started, gm1.waitone( )
t3start started, mutex.waitany(mutex[])
t4start started, gm2.waitone( )
 - main releases gm1
t2start finished, gm1.waitone( ) satisfied
t3start finished, mutex.waitany(mutex[])
 - main releases gm2
t1start finished, mutex.waitall(mutex[]) satisfied
t4start finished, gm2.waitone( )
 mutex sample

从执行结果可以很清楚地看到，线程t2,t3的运行是以gm1的释放为条件的，而t4在gm2释放后开始执行，t1则在gm1和gm2都被释放了之后才执行。main()函数最后，使用waithandle等待所有的autoresetevent对象的信号，这些对象的信号代表相应线程的结束。

希望本文所述对大家的c#程序设计有所帮助。