信号量：了解初始和最大请求​​数

Question

I'm learning c# semaphore and don't understand one point. I can initialize Semaphore like this:

var semaphore = new Semaphore(4, 6);

There is such explanation in many places:

If you want to reserve some slots for the calling thread, you can do so by making the first parameter smaller than the second.

Does it mean that only main thread can use remaining 2 resource slots? Does it mean that if I write like this:

var semaphore = new Semaphore(0, 6);

only main thread can use all 6 slots?

Answer 1

I like Albahari's explanation :

A semaphore is like a nightclub: it has a certain capacity, enforced by a bouncer. Once it's full, no more people can enter, and a queue builds up outside. Then, for each person that leaves, one person enters from the head of the queue. The constructor requires a minimum of two arguments: the number of places currently available in the nightclub and the club's total capacity.

Answer 2

Unlike lock (Monitor) and Mutex, Semaphore has no “owner” — it's thread-agnostic. Any thread can call Release on a Semaphore, whereas with Mutex and lock, only the thread that obtained the lock can release it.

Initial value can be used to initiate number of requests for the semaphore that can be granted concurrently. it sets your currently available concurrency level for related sempahore.

While maximum count sets maximum number of requests for the semaphore that can be granted concurrently. it sets your maximum potential concurrency for related semaphore.

You can't increment the counter CurrentCount greater than maximum count which you set in initialization.

Following sample shows how Semaphores are Thread agnostic:

    private static Semaphore semaphore = new Semaphore(3, 6);

    private static void Main(string[] args)
    {
        //semaphore.Release(); //openning another slot for concurreny

        semaphore.WaitOne();
        Console.WriteLine("main0");
        new Thread(() =>
        {
            semaphore.WaitOne();
            Console.WriteLine("thread0");
            semaphore.WaitOne();
            Console.WriteLine("thread1");
            Thread.Sleep(3000);
            Console.WriteLine("uncomment the release line to make main1 get in");

        }).Start();

        Thread.Sleep(1000);
        semaphore.WaitOne();
        Console.WriteLine("main1");
        Console.ReadKey();
    }

for more information have a look at http://www.albahari.com/threading/part2.aspx#_Semaphore

Answer 3

Unlike a mutex, a semaphore can Release() and WaitOne() in any thread. WaitOne() — counter in Semaphore decrement. If counter == 0, blocks until it increases. Release() — counter in Semaphore increment. Second constructor parameter == counter, blocks until it decreases.