[.net 多线程]Semaphore信号量

　　信号量(Semaphore)是一种CLR中的内核同步对象。与标准的排他锁对象（Monitor，Mutex，SpinLock）不同的是，它不是一个排他的锁对象，它与SemaphoreSlim，ReaderWriteLock等一样允许多个有限的线程同时访问共享内存资源。Semaphore就好像一个栅栏，有一定的容量，当里面的线程数量到达设置的最大值时候，就没有线程可以进去。然后，如果一个线程工作完成以后出来了，那下一个线程就可以进去了。Semaphore的WaitOne或Release等操作分别将自动地递减或者递增信号量的当前计数值。当线程试图对计数值已经为0的信号量执行WaitOne操作时，线程将阻塞直到计数值大于0。

　　Semaphore是表示一个Windows内核的信号量对象（操作系统级别，可以跨进程或AppDomain）。如果预计等待的时间较短，使用SemaphoreSlim（单进程）带来的开销更小。关于两者的区别如下：

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

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

Semaphore的WaitOne或者Release方法的调用大约会耗费1微秒的系统时间，而优化后的SemaphoreSlim则需要大致四分之一微秒。在计算中大量频繁使用它的时候SemaphoreSlim还是优势明显，所以在4.0以后的多线程开发中，推荐使用SemaphoreSlim。

在构造Semaphore时，最少需要2个参数。信号量的初始容量和最大的容量。

[SecuritySafeCritical]
[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
public Semaphore(int initialCount, int maximumCount);

Semaphore

initialCount：信号量可以接受的并发请求数量的初始容量

maximumCount：信号量可以接受的并发请求数量的最大容量

示例代码：

 using System;
 using System.Threading;
 using System.Threading.Tasks;
 
 public class Example
 {
     private static SemaphoreSlim semaphore;
     // A padding interval to make the output more orderly.
     private static int padding;
 
     public static void Main()
     {
         // Create the semaphore.
         semaphore = new SemaphoreSlim(, );
         Console.WriteLine("{0} tasks can enter the semaphore.",
                           semaphore.CurrentCount);
         Task[] tasks = new Task[];
 
         // Create and start five numbered tasks.
         for(int i = ; i <= ; i++)
         {
             tasks[i] = Task.Run( () => {
             // Each task begins by requesting the semaphore.
             Console.WriteLine("Task {0} begins and waits for the semaphore.",
                               Task.CurrentId);
             semaphore.Wait();
 
             Interlocked.Add(ref padding, );
 
             Console.WriteLine("Task {0} enters the semaphore.", Task.CurrentId);
 
             // The task just sleeps for 1+ seconds.
             Thread.Sleep( + padding);
 
             Console.WriteLine("Task {0} releases the semaphore; previous count: {1}.",
                               Task.CurrentId, semaphore.Release()); } );
         }
 
         // Wait for half a second, to allow all the tasks to start and block.
         Thread.Sleep();
 
         // Restore the semaphore count to its maximum value.
         Console.Write("Main thread calls Release(3) --> ");
         semaphore.Release();
         Console.WriteLine("{0} tasks can enter the semaphore.",
                           semaphore.CurrentCount);
         // Main thread waits for the tasks to complete.
         Task.WaitAll(tasks);
 
         Console.WriteLine("Main thread exits.");
     }
 }
 // The example displays output like the following:
 //       0 tasks can enter the semaphore.
 //       Task 1 begins and waits for the semaphore.
 //       Task 5 begins and waits for the semaphore.
 //       Task 2 begins and waits for the semaphore.
 //       Task 4 begins and waits for the semaphore.
 //       Task 3 begins and waits for the semaphore.
 //       Main thread calls Release(3) --> 3 tasks can enter the semaphore.
 //       Task 4 enters the semaphore.
 //       Task 1 enters the semaphore.
 //       Task 3 enters the semaphore.
 //       Task 4 releases the semaphore; previous count: 0.
 //       Task 2 enters the semaphore.
 //       Task 1 releases the semaphore; previous count: 0.
 //       Task 3 releases the semaphore; previous count: 0.
 //       Task 5 enters the semaphore.
 //       Task 2 releases the semaphore; previous count: 1.
 //       Task 5 releases the semaphore; previous count: 2.
 //       Main thread exits.

SemaphoreSlim示例

Samaphore实现：https://blog.csdn.net/ma_jiang/article/details/78631038