C# 多线程系列之Semaphore使用

Semaphore，即信号量的意思。是操作系统原始提供的内核同步对象。

Semaphore semaphoreAcceptedClients = new Semaphore(, 3,"Semaphore1");

解释一下意思：

第一个参数为：initialCount ，意指初始数量。Semaphore这个对象的使用是这么回事：在initialCoun设置为0的时候，WaitOne()方法会直接阻塞。至饿到它的Release方法被调用位置。但是如果initialCount>0，那么一开始便不会阻塞WaitOne方法N次。

第二个参数为maximumCount，即最大并发数。

第三个参数的话，我刚说它是操作系统的内核对象，那么又是可以用作跨进程线程同步的。

MSDN：http://msdn.microsoft.com/en-us/library/system.threading.semaphore(v=vs.110).aspx

举例：

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.
        //
        _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();

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

    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( + padding);

        Console.WriteLine("Thread {0} releases the semaphore.", num);
        Console.WriteLine("Thread {0} previous semaphore count: {1}",
            num, _pool.Release());
    }
}

跨进程的同步的话

A进程：

Semaphore semaphoreAcceptedClients = new Semaphore(, ,"Semaphore1");

B进程：

Semaphore semaphoreAcceptedClients2 = Semaphore.OpenExisting("Semaphore1");

使用和单进程中的线程同步一致。

完毕。