多线程之旅(6)_Semaphore和SemaphoreSlim关于WaitOne、Release的用法详解——附C#源码

Semaphore、WaitOne、Release三者组成了一个互斥信号量的完整体系结构。Semaphore、WaitOne、Release究竟和AutoResetEvent/ManualResetEvent、WaitOne、Set、Reset有什么区别呢？我们往下看。

GitHub源码地址：https://github.com/yangwohenmai/TEST/tree/master/SemaphoreSlim

1.Semaphore定义

Semaphore,是负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。也是操作系统中用于控制进程同步互斥的量。

Semaphore常用的方法有两个WaitOne()和Release()，Release()的作用是退出信号量并返回前一个计数，而WaitOne()则是阻止当前线程，直到当前线程的WaitHandle 收到信号。这里我举一个例子让大家更容易理解：

当我们这样实例化Semaphore时候，如果写Semaphore sema = new Semaphore(x,y)这种表达式，就可以理解为这样一个场景

有一队人排队上洗手间，人就相当于线程，x为还剩余的位置数量，y为总的位置数量。

WaitOne()方法就相当于人在等待洗手间位置的行为，而Release()方法就相当于一个人从洗手间出来的行为，这里再假设x和y都为5，说明开始的时候洗手间有5个空位置，且总共只有5个位置，当一队超过5个人的队伍要上洗手间的就排队，首先WaitOne()方法等待，发现有空位就依次进去，每进去一个空位减一，直到进去5之后个没有空位，这时候后面的人就一直等待，直到进去的人从洗手间出来Release()方法，空位加一，在等待WaitOne()方法的人发现有空位又进去一个空位减一……如此循环往复。

2.Semaphore的使用

Semaphore常用的方法有两个：WaitOne()和Release()，Release()的作用是退出信号量并返回前一个计数，而WaitOne()则是阻止当前线程，直到当前线程的WaitHandle 收到信号。

回想一下大学学习计算机操作系统时，就讲到了互斥量，哲学家就餐等问题。其实用的互斥变量就是我们今天要讲的Semaphore。Semaphore，WaitOne，Release的说明很简单，但是用起来还是有很多有趣的小细节：

（1）Semaphore(int initialCount, int maximumCount)

Semaphore可以理解为一个资源信号量的容器，initialCount，maximumCount两个参数分别代表初始资源数和最大资源数。

所谓最大资源数maximumCount，是指Semaphore容器中所包含的所有资源的数量。这个最大资源数maximumCount中，包括当前可用的资源，和当前尚未释放的资源。

而初始资源数initialCount，是指在程序初始状态时，Semaphore释放出了多少个可以直接被线程使用的资源。

尚未被释放的资源 = maximumCount - initialCount

（2）Semaphore.WaitOne()

WaitOne()方法可以从Semaphore这个资源容器中的现有可用资源中，取出一个资源，但要注意的是WaitOne()方法只能从Semaphore中取出已经释放的资源，而不能取出尚未释放的资源。

这句话比较绕，是什么意思呢，比如在程序一开始我们配置了资源容器的参数为Semaphore(3,6)，那么初始可用的资源有3个。此时使用WaitOne()最多只能从Semaphore中取出3个资源，虽然总共的资源有6个，但是剩下的3个资源WaitOne()无法直接使用，只能等待其他程序主动释放。

WaitOne有一些重载的方法：

public virtual bool WaitOne(TimeSpan timeout); 
public virtual bool WaitOne(int millisecondsTimeout);

第一个重载参数timeout：指定时间间隔，若在这段时间内没有接收到信号则跳过等待继续执行。

第二个重载参数millisecondsTimeout：指定时间间隔整数毫秒，若在这段时间内没有接收到信号则跳过等待继续执行。

（3）Semaphore.Release(n)

Release(n)方法可以从Semaphore这个资源容器中释放n个资源，n就是释放的资源数量，Release(n)不但可以释放自己的资源，还可以释放Semaphore在初始时不可用的资源。

比如资源容器Semaphore(3,6)的总资源为6，初始可用资源为3，使用Release(n)方法可以将剩下3个不可用的资源释放出来，使得Semaphore有6个可用资源。

给个示例：

        //一共有6个资源，初始时释放一个资源
        static Semaphore _semaphor = new Semaphore(1,6);
        static void Main(string[] args)
        {

            //开启6个线程
            for (int i = 1; i <= 6; i++)
            {
                string threadName = "Thread" + i;
                int secondsToWait = 2 + 2 * i;
                var t = new Thread(() => _semaphorT(threadName, secondsToWait));
                t.Start();
            }
            Console.ReadKey();
        }


        static void _semaphorT(string name, int seconds)
        {
            Console.WriteLine("{0} 等待信号量", name);
            //获取一个资源
            _semaphor.WaitOne();
            Console.WriteLine("{0} 获得信号量，开始执行", name);
            Thread.Sleep(1000 * seconds);
            Console.WriteLine("{0} 结束", name);
            //释放5个资源
            _semaphor.Release(5);
        }

从上述代码可以看出，程序中我们设定一个容器，共有6个资源，但初始状态下只有1个资源可用。

static Semaphore _semaphor = new Semaphore(1,6);

在线程方法_semaphorT中最后一行代码如下，表示当一个线程执行完之后，会从_semaphor资源容器中释放5个资源，可以提供给其他线程使用。

 _semaphor.Release(5);

运行结果如下图：

从图中可以看出，在程序启动时，一开始创建了6个线程，但是只有1个线程获取到信号量，开始执行。当第一个线程执行结束后，释放了5个资源，其余5个线程都获取到了资源，开始运行。

n指的是释放的信号量数量，如果没有参数则默认为1，Release()就相当于Release(1)

这里要说明一点，当Release()或者Release(int releaseCount)执行时导致信号量计数大于最大数量时会抛出SemaphoreFullException异常。下面这种情况就会异常：

Semaphore sem = new Semaphore(4,5);
//这里是释放2个资源，加上初始可用的4个资源，总数超出了5个最大资源数量
sem.Release(2);

 

 

三.WaitOne()和Release(n)的使用细节和技巧

通过上述特性，我们可以组合用一些有用的用法。

1.比如在一个线程中我们可以使用两次WaitOne()方法，这样的话这个线程就占有了两个资源。

这样的使用场景很多，比如有一个线程很消耗系统性能时，我们可以使WaitOne()方法多占用几个资源，这样可以使得当这个线程在执行时，系统中同时并发执行的线程总数较少。根据不同线程对系统资源的消耗，配置相应的资源占有量，可以达到对系统资源的合理分配。

2.同时我们在一个线程中也可以通过使用多个Release(n)方法，来分步释放资源。

比如一个很消耗系统性能的线程在执行时，每当线程执行完一部分运算步骤（系统性能消耗减少），就可以释放一部分资源，使得部分其他消耗少量系统资源的线程可以启动起来。直到最后释放完所有的资源。

示例代码如下：

        //一共有6个资源，初始时释放一个资源
        static Semaphore _semaphor = new Semaphore(2,6);
        static void Main(string[] args)
        {

            //开启6个线程
            for (int i = 1; i <= 6; i++)
            {
                string threadName = "Thread" + i;
                int secondsToWait = 2 + 2 * i;
                var t = new Thread(() => _semaphorT(threadName, secondsToWait));
                t.Start();
            }
            Console.ReadKey();
        }


        static void _semaphorT(string name, int seconds)
        {
            Console.WriteLine("{0} 等待信号量", name);
            //获取2个资源
            _semaphor.WaitOne();
            _semaphor.WaitOne();
            Console.WriteLine("{0} 获得信号量，开始执行", name);
            Thread.Sleep(1000 * seconds);
            Console.WriteLine("{0} 结束", name);
            //释放5个资源
            _semaphor.Release(2);
        }

从上述代码可以看出，_semaphor总的资源一共有6个，初始状态下，有2个资源是可用的。

在 _semaphorT方法中，有2个WaitOne，说明每个线程获取2个资源后才能正常执行，在_semaphorT方法最后_semaphor.Release(2)表示，执行完当前线程后，释放2个资源供其他线程调用。

执行结果如下图：

由此可见，第一个线程获取到2个初始资源后，满足条件开始执行。当第一个线程执行完后，释放了2个资源。但此时并没有后续的指标开始启动。

原因很简单，刚释放的两个资源，被剩余线程中，不同的两个线程，各抢占了1个资源，此时大家都在等其他线程释放资源，但是没有线程可以继续执行，因为都不满足“同时拥有2个资源”的这个可以执行条件，占有1个资源的线程也不释放，就在那耗着，这也就是程序遇到了传说中的死锁。

四.SemaphoreSlim和Semaphore的区别

System.Threading.Semaphore：类表示一个命名（系统范围内）或本地信号量。它是环绕 Win32 信号量对象的精简包装器。Win32 信号量是计数信号量，该可用于控制对资源池的访问。

SemaphoreSlim： 类表示一个轻量、快速的信号量，可在等待时间预计很短的情况下用于在单个进程内等待。 SemaphoreSlim也称为是Semaphore的一个简化版。SemaphoreSlim 尽可能多地依赖公共语言运行时 (CLR) 提供的同步基元。但是，它还提供延迟初始化、基于内核的等待句柄，作为在多个信号量上进行等待的必要支持。 SemaphoreSlim 也支持使用取消标记，但不支持命名信号量或使用用于同步的等待句柄。

为什么说SemaphoreSlim是Semaphore的简化版？

因为Semaphore继承了WaitHandle，而WaitHandle继承了MarshalByRefObject和IDisposable。

而SemaphoreSlim只继承了IDisposable，很显然是简版的Semaphore

Semaphore的WaitOne或者Release方法的调用大约会耗费1微秒的系统时间，而优化后的SemaphoreSlim则需要大致四分之一微秒。在计算中大量频繁使用它的时候SemaphoreSlim还是优势明显，加上SemaphoreSlim还丰富了不少接口，更加方便我们进行控制，所以在4.0以后的多线程开发中，推荐使用SemaphoreSlim。

（相关链接：https://msdn.microsoft.com/zh-cn/library/z6zx288a(v=vs.110).aspx）

五.与AutoResetEvent/ManualResetEvent、WaitOne、Set、Reset区别

这个看起来好像和线程阻塞的WaitOne、Set、Reset这一套机制很像，猛一看是有相似之处。但其实并不是同一种东西，区别是什么呢？

1.AutoResetEvent/ManualResetEvent的WaitOne、Set、Reset机制是用来做线程同步用的，主要目的在于帮助程序理清楚线程之间的先后关系。关于 AutoResetEvent/ManualResetEvent、WaitOne、Set、Reset的用法可以看下面这篇文章：

多线程之旅(1)_线程同步之AutoResetEvent和ManualResetEvent的区别、用法——附C#源码示例 

2.Semaphore、WaitOne、Release这一套机制是用来对线程的资源使用情况进行控制，避免程序出现死锁。