信号量是一种锁定资源的方法，以保证在执行一段代码时，只有这段代码可以访问该资源。这可以防止两个线程并发访问一个资源，从而导致问题。

信号量是一种锁定资源的方法，以保证在执行一段代码时，只有这段代码可以访问该资源。这可以防止两个线程并发访问一个资源，从而导致问题。

把信号量想象成夜总会的保镖。同时允许进入俱乐部的人数是固定的。如果俱乐部满了，任何人都不允许进入，但只要一个人离开，另一个人就可以进入。

它只是一种限制特定资源的消费者数量的方法。例如，限制应用程序中对数据库的同时调用数量。

下面是一个非常适合教学的c#例子:-)

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace TheNightclub
{
    public class Program
    {
        public static Semaphore Bouncer { get; set; }

        public static void Main(string[] args)
        {
            // Create the semaphore with 3 slots, where 3 are available.
            Bouncer = new Semaphore(3, 3);

            // Open the nightclub.
            OpenNightclub();
        }

        public static void OpenNightclub()
        {
            for (int i = 1; i <= 50; i++)
            {
                // Let each guest enter on an own thread.
                Thread thread = new Thread(new ParameterizedThreadStart(Guest));
                thread.Start(i);
            }
        }

        public static void Guest(object args)
        {
            // Wait to enter the nightclub (a semaphore to be released).
            Console.WriteLine("Guest {0} is waiting to entering nightclub.", args);
            Bouncer.WaitOne();          

            // Do some dancing.
            Console.WriteLine("Guest {0} is doing some dancing.", args);
            Thread.Sleep(500);

            // Let one guest out (release one semaphore).
            Console.WriteLine("Guest {0} is leaving the nightclub.", args);
            Bouncer.Release(1);
        }
    }
}

我已经创建了可视化，这应该有助于理解这个想法。信号量控制多线程环境中对公共资源的访问。

ExecutorService executor = Executors.newFixedThreadPool(7);

Semaphore semaphore = new Semaphore(4);

Runnable longRunningTask = () -> {
    boolean permit = false;
    try {
        permit = semaphore.tryAcquire(1, TimeUnit.SECONDS);
        if (permit) {
            System.out.println("Semaphore acquired");
            Thread.sleep(5);
        } else {
            System.out.println("Could not acquire semaphore");
        }
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    } finally {
        if (permit) {
            semaphore.release();
        }
    }
};

// execute tasks
for (int j = 0; j < 10; j++) {
    executor.submit(longRunningTask);
}
executor.shutdown();

输出

Semaphore acquired
Semaphore acquired
Semaphore acquired
Semaphore acquired
Could not acquire semaphore
Could not acquire semaphore
Could not acquire semaphore

本文中的示例代码

硬件或软件标志。在多任务系统中，信号量是一个变量，其值表示公共资源的状态。需要资源的进程检查信号量以确定资源状态，然后决定如何继续。

这是一个老问题，但信号量最有趣的用途之一是读/写锁，但没有明确提到。

r/w锁的工作方式很简单:为读取器消耗一个许可证，为写入器消耗所有许可证。 事实上，一个简单的r/w锁实现，但需要在读取时修改元数据(实际上是两次)，这可能会成为瓶颈，但仍然比互斥锁或锁好得多。

另一个缺点是，写入也可以很容易地启动，除非信号量是公平的，或者写入在多个请求中获得许可，在这种情况下，它们之间需要一个显式的互斥。

进一步阅读: