C#线程同步–信号量和互斥体

一、信号量（Semaphore）

信号量（Semaphore）是由内核目标保护的int变量。当信号量为0时，在信号量上等候的线程会阻塞；信号量大于0时，就免除阻塞。当在一个信号量上等候
的线程免除阻塞时，内核主动会将信号量的计数减1。在.NET下经过Semaphore类来完成信号量同步。
Semaphore类限制可一起访问某一资源或资源池的线程数。线程经过调用WaitOne办法将信号量减1，并经过调用Release办法把信号量加1。
先说下构造函数：
publicSemaphore(intinitialCount,intmaximumCount);经过两个参数来设置信号的初始计数和最大计数。

下面代码演示信号量同步的运用：
classProgram
{//共享资源publicstaticintnumber=0;//初始信号量计数为0，最大计数为10。publicstaticSemaphoresemaphore=newSemaphore(0,10);staticvoidMain(string[]args)
{#region线程同步：运用信号量完成同步for(inti=0;i<10;i++)
{
Threadthread=newThread(newParameterizedThreadStart(SemaphoreMethod));
thread.Start(i);
}//每次增加2个信号量，即每次开释2个线程。for(intj=0;j<5;j++)
{
Console.WriteLine(“红灯转绿灯……”);
semaphore.Release(2);
Thread.Sleep(1000);
}
Console.Read();#endregion}//////Semaphore办法///publicstaticvoidSemaphoreMethod(objectparameter)
{while((int)parameter!=number)
{
Thread.Sleep(100);
}//信号量计数减1semaphore.WaitOne();
Console.WriteLine(“Thecurrentvalueofnumberis:{0}”,++number);
}
}
运转成果如下：
与上一篇AutoResetEvent类似，信号量也能够完成迈进程间的线程同步。经过调用publicSemaphore(intinitialCount,intmaximumCount,stringname);构造函数，
传入一个信号量名来完成此功能。
下面代码演示迈进程间的线程同步：
第一个进程代码：
classProgram
{//共享资源publicstaticintnumber=0;//初始信号量计数为0，最大计数为10。publicstaticSemaphoresemaphore1=newSemaphore(0,10,”Semaphore1″);publicstaticSemaphoresemaphore2=newSemaphore(0,10,”Semaphore2″);staticvoidMain(string[]args)
{#region线程同步：运用信号量完成迈进程之间的线程同步for(inti=0;i<10;i++)
{
Threadthread=newThread(newParameterizedThreadStart(Semaphore1Method));
thread.Start(i);
}//为了有时间去发动另外一个进程Thread.Sleep(15000);//每次增加2个信号量，即每次开释2个线程。for(intj=0;j<5;j++)
{
Console.WriteLine(“信号灯1红灯转绿灯……”);
semaphore1.Release(2);
Console.WriteLine(“信号灯2红灯转绿灯……”);
semaphore2.Release(2);
Thread.Sleep(1000);
}
Console.Read();#endregion}//////Semaphore1办法///publicstaticvoidSemaphore1Method(objectparameter)
{while((int)parameter!=number)
{
Thread.Sleep(100);
}//信号量计数减1semaphore1.WaitOne();
Console.WriteLine(“Semaphore1:Thecurrentvalueofnumberis:{0}”,++number);
}
}
第二个进程代码：
classProgram
{//共享资源publicstaticintnumber=0;//创立目标publicstaticSemaphoresemaphore2=newSemaphore(0,10,”Semaphore2″);staticvoidMain(string[]args)
{#region经过信号量完成迈进程间的线程同步for(inti=0;i<10;i++)
{
Threadthread=newThread(newParameterizedThreadStart(Semaphore2Method));
thread.Start(i);
}
Console.Read();#endregion}//////Semaphore2办法///publicstaticvoidSemaphore2Method(objectparameter)
{while((int)parameter!=number)
{
Thread.Sleep(100);
}//信号量计数减1semaphore2.WaitOne();
Console.WriteLine(“Semaphore2:Thecurrentvalueofnumberis:{0}”,++number);
}
}
运转成果如下：
从成果能够看出，第一个进程的semaphore2.Release(2);信号宣布后，第二个进程能够收到并开释线程。
二、互斥体（Mutex）
Mutex目标是一个同步基元，当某一个线程占用Mutex目标时，其他也需求占用Mutex的线程将处于挂起状况。
下面代码演示互斥体同步的运用：
classProgram
{//共享资源publicstaticintnumber=0;//互斥体publicstaticMutexmutex=newMutex();staticvoidMain(string[]args)
{#region线程同步：运用互斥体完成同步for(inti=0;i<10;i++)
{
Threadthread=newThread(MutexMethod);
thread.Start();
}
Console.Read();#endregion}//////Mutex办法///publicstaticvoidMutexMethod(objectparameter)
{
mutex.WaitOne();
Thread.Sleep(500);
Console.WriteLine(“Thecurrentvalueofnumberis:{0}”,++number);
mutex.ReleaseMutex();
}
}
运转成果如下：
下面代码演示迈进程间的线程同步：
第一个进程代码：
classProgram
{//共享资源publicstaticintnumber=0;//互斥体publicstaticMutexmutex1=newMutex(false,”Mutex1″);publicstaticMutexmutex2=newMutex(false,”Mutex2″);staticvoidMain(string[]args)
{#region线程同步：运用互斥体完成迈进程之间的线程同步mutex1.WaitOne();
mutex2.WaitOne();for(inti=0;i<10;i++)
{
Threadthread=newThread(newParameterizedThreadStart(Mutex1Method));
thread.Start(i);
}//为了有时间去发动另外一个进程Thread.Sleep(15000);
mutex1.ReleaseMutex();
mutex2.ReleaseMutex();
Console.Read();#endregion}//////Mutex1办法///publicstaticvoidMutex1Method(objectparameter)
{
mutex1.WaitOne();
Thread.Sleep(500);
Console.WriteLine(“Mutex1:Thecurrentvalueofnumberis:{0}”,++number);
mutex1.ReleaseMutex();
}
}
第二个进程代码：
classProgram
{//共享资源publicstaticintnumber=0;//创立目标publicstaticMutexmutex2=newMutex(false,”Mutex2″);staticvoidMain(string[]args)
{#region经过互斥体完成迈进程之间的线程同步for(inti=0;i<10;i++)
{
Threadthread=newThread(newParameterizedThreadStart(Mutex2Method));
thread.Start(i);
}
Console.Read();#endregion}//////Mutex2办法///publicstaticvoidMutex2Method(objectparameter)
{
mutex2.WaitOne();
Thread.Sleep(500);
Console.WriteLine(“Mutex2:Thecurrentvalueofnumberis:{0}”,++number);
mutex2.ReleaseMutex();
}
}
运转成果如下：
从成果能够看出，第一个进程的mutex2.ReleaseMutex();信号宣布后，第二个进程能够收到并开释线程。