public sealed class Semaphore :WaitHandle{

    //初始化信号量：初始请求数为initialCount，最大请求数为maximumCount

    public Semaphore(Int32 initialCount,Int32 maximumCount);

    public Int32 Release();//调用Release(1);返回上一个计数

    public Int32 Release(Int32 releaseCount);//返回上一个计数

 }

initialCount:就是初始化信号量时，解除阻塞的线程数。

maximumCount：就是信号量允许执行的最大线程数。

 using System;

 using System.Threading;

 public class Example

 {

     // A semaphore that simulates a limited resource pool.

     //

     private static Semaphore _pool;

     // A padding interval to make the output more orderly.

     private static int _padding;

     public static void Main()

     {

         // Create a semaphore that can satisfy up to three

         // concurrent requests. Use an initial count of zero,

         // so that the entire semaphore count is initially

         // owned by the main program thread.

         //初始化时允许解除的阻塞线程数量为0，最大的执行线程数为3，所以在第执行完第44行代码之前，开启的子线程中的代码都不会执行，如果注释掉第45行代码，这5个子线程都不会执行，如果改成:new Semaphore(1,3)初始化时允许解除的阻塞线程数量为1，最大执行的线程数为3，所以在执行完31行代码后会有一个子线程在运行的，如果注释掉第45行代码，就会只有一个信号量慢慢的运行完这5个子线程

         _pool = new Semaphore(, );

         // Create and start five numbered threads.

         //

         for (int i = ; i <= ; i++)

         {

             Thread t = new Thread(new ParameterizedThreadStart(Worker));

             // Start the thread, passing the number.

             //

             t.Start(i);

         }

         // Wait for half a second, to allow all the

         // threads to start and to block on the semaphore.

         //

         Thread.Sleep();

         // The main thread starts out holding the entire

         // semaphore count. Calling Release(3) brings the

         // semaphore count back to its maximum value, and

         // allows the waiting threads to enter the semaphore,

         // up to three at a time.

         //

         Console.WriteLine("Main thread calls Release(3).");

         _pool.Release();//此句代码的通俗意思就是重新再增加3个可以执行的线程，如果初始化new semaphore（1，5）运行完这代代码就是1+3=4个线程数解除阻塞了，如果初始化为new  semaphore(0,5)运行完这段代码就是0+3=3个线程数解除阻塞了。

         //Console.WriteLine("_pool {0}", _pool.Release());

         //Console.WriteLine("_pool {0}", _pool.Release());

         //Console.WriteLine("_pool {0}", _pool.Release());

         //Console.WriteLine("_pool {0}", _pool.Release());

         //Console.WriteLine("_pool {0}", _pool.Release());

         Console.WriteLine("Main thread exits.");

        // Thread.Sleep(5000);

        // Console.WriteLine("_pool {0}", _pool.Release());

         Console.ReadLine();

     }

     private static void Worker(object num)

     {

         // Each worker thread begins by requesting the

         // semaphore.

         Console.WriteLine("Thread {0} begins " +

             "and waits for the semaphore.", num);

         _pool.WaitOne();

         // A padding interval to make the output more orderly.

         int padding = Interlocked.Add(ref _padding, );

         Console.WriteLine("Thread {0} enters the semaphore.", num);

         // The thread's "work" consists of sleeping for

         // about a second. Each thread "works" a little

         // longer, just to make the output more orderly.

         //模拟阻塞线程

          Thread.Sleep(1000 + padding);

         Console.WriteLine("Thread {0} releases the semaphore.", num);

         Console.WriteLine("Thread {0} previous semaphore count: {1}",

             num, _pool.Release());

     }

 }
运行的其中之一的一个结果为:

Thread  begins and waits for the semaphore.

Thread  begins and waits for the semaphore.

Thread  begins and waits for the semaphore.

Thread  begins and waits for the semaphore.

Thread  begins and waits for the semaphore.

Main thread calls Release().

Thread  enters the semaphore.

Thread  releases the semaphore.

Thread  previous semaphore count:

Thread  enters the semaphore.

Thread  releases the semaphore.

Thread  previous semaphore count:

Thread  enters the semaphore.

Thread  releases the semaphore.

Thread  previous semaphore count:

Main thread exits.

Thread  enters the semaphore.

Thread  releases the semaphore.

Thread  previous semaphore count: 1 //执行这段代码前。信号量(semaphore)中还有两个线程在执行（当前运行运行的线程和下面还没运行完的一个线程，所以剩余1个线程的信号量(semaphore)可以执行.

Thread  enters the semaphore.

Thread  releases the semaphore.

Thread  previous semaphore count: 2 //执行这段代码前。信号量(semaphore)中有2个空闲的位置，可以执行线程了。

 这只是自己的理解，不正确的望各位大侠们指教。。。。。。。。。。。。。。。