Semaphore，中文名字叫“信号量”，来自 JUC 家族（java.util.concurrent）。家族有很多优秀的成员，比如：CountDownLatch：等待其他线程都执行完再执行某线程。
CyclicBarrier：循环阻塞一组线程，直到某个事件达成。
Java 中的一个同步器，与 CountDownLatch 和 CyclicBarrier 不同，Semaphore 是用来管理许可证的，线程在调用 acquire() 方法时，如果没有许可证，那么线程就会阻塞等待，直到有许可证时才能继续执行。许可证使用 release() 方法来发布（发布一个许可证），调用 acquire() 方法时，如果有证书会减少许可证并继续执行后面的代码，如果没有证书只能阻塞等待许可证，而 Semaphore 在创建时会声明许可证的最大数量。

什么是限流

比如五一小长假快到了，到那时会有大量的人去各个景区游玩，但是每个景区能容纳的人是有限的，比如大西安的大唐芙蓉园，它的日承载量是 6 万人次，也就是说每天最多能让 6 万来这里游玩，但五一的时候会来很多的人，比如突然来了 10 万人，那这个时候就只能「限流」排队等待入园了。

也就说，大唐芙蓉园会让 6 万人先进去玩，剩余的人在门口等待排队，当有人从里面出来的时候，才允许另一个排队的人进去。工作人员会把人数始终控制在 6 万人以下，这样做的目的是为了让游玩的人有一个好的体验，不至于造成一些意外事故，比如踩踏事件什么的，一定程度上保证了社会的稳定，也便于景区良好的口碑建立和日后的正常运营，而这种排队限制最大人数的行为就是「限流」。

再来举个例子，比如以车辆的限号来说，它也是限流的一种常见场景。这样做的好处，一方面是可以保护环境尽可能少一些碳排放，另一方面能有效的缓解上、下班高峰时段的拥堵情况。尤其是在大西安，很难想象如果不限号，那么会堵成什么样？（PS：让原本本不富裕的生活更是雪上加霜…）

咱们再从生活中的事例回到程序当中，假设一个程序只能为 10W 人提供服务，突然有一天因为某个热点事件，造成了系统短时间内的访问量迅速增加到了 50W，那么导致的直接结果是系统崩溃，任何人都不能用系统了，显然只有少人数能用远比所有人都不能用更符合我们的预期，因此这个时候我们要使用「限流」了。

使用Semaphore实现限流

Semaphore 在创建的时候可以设置证书的数量，相当于设置了限流的最大值，再通过 release() 方法来发放证书，通过 acquire() 方法来阻塞并等待证书，这样就通过控制证书的方式来实现限流功能了。

代码实例

使用代码的方式来演示 Semaphore 的使用。我们以停车场的限流为例，假设整个停车场只有 2 个车位（车位虽少，但足矣说明问题），但来停车的却有 5 辆车，显然车位不够用了，此时需要保证停车场最多只能有 2 辆车，接下来咱们使用 Semaphore 来实现车辆的限流功能，具体实现代码如下：

  1. import java.util.Date;
  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  4. import java.util.concurrent.Semaphore;
  6. /**
  7.  * Author：磊哥
  8.  * By：Java中文社群
  9.  */
  10. publicclass SemaphoreExample {
  11.     // 创建信号量
  12.     static Semaphore semaphore = new Semaphore(2);
  14.     public static void main(String[] args) {
  16.         // 创建 5 个固定的线程数
  17.         ExecutorService threadPool = Executors.newFixedThreadPool(5);
  19.         // 定义执行任务
  20.         Runnable runnable = new Runnable() {
  21.             @Override
  22.             public void run() {
  23.                 // 拿到当前线程的名称
  24.                 String tname = Thread.currentThread().getName();
  25.                 System.out.println(String.format("老司机：%s，停车场外排队，时间：%s",
  26.                         tname, new Date()));
  27.                 try {
  28.                     // 执行此行，让所有线程先排队等待进入停车场
  29.                     Thread.sleep(100);
  30.                     // 执行阻塞
  31.                     semaphore.acquire();
  32.                     System.out.println(String.format("老司机：%s，已进入停车场，时间：%s",
  33.                             tname, new Date()));
  34.                     Thread.sleep(1000);
  35.                     System.out.println(String.format("老司机：%s，离开停车场，时间：%s",
  36.                             tname, new Date()));
  37.                     // 释放锁
  38.                     semaphore.release();
  39.                 } catch (InterruptedException e) {
  40.                     e.printStackTrace();
  41.                 }
  42.             }
  43.         };
  45.         // 执行任务 1
  46.         threadPool.submit(runnable);
  48.         // 执行任务 2
  49.         threadPool.submit(runnable);
  51.         // 执行任务 3
  52.         threadPool.submit(runnable);
  54.         // 执行任务 4
  55.         threadPool.submit(runnable);
  57.         // 执行任务 5
  58.         threadPool.submit(runnable);
  60.         // 等线程池任务执行完之后关闭
  61.         threadPool.shutdown();
  62.     }
  63. }

以上代码的执行结果如下：
Semaphore - 图1
从上述的结果我们可以看出，当有 5 辆车同时需要进入停车场时，因为停车场的停车位只有 2 个，所以停车场最多只能容纳 2 辆车。此时我们通过 Semaphore 的 acquire 方法（阻塞等待）和 release 方法（颁发一个证书）顺利的实现了限流的功能，让停车场的车辆数始终控制在 2 辆车以下（等于或小于 2 辆车）。

个人评价

（Semaphore）实现证书控制手段有两种，一种公平模式和非公平模式，当然为了执行的性能考虑，默认情况下我采取的是非公平的方式，具体实现可见源码：

  1. public Semaphore(int permits) {
  2.     sync = new NonfairSync(permits); // 非公平模式
  3. }

关于公平模式和非公平模式

所谓的公平模式就是以调用 acquire() 的先后顺序来决定获取许可证的顺序的，公平模式遵循先进先出（FIFO）原则；而非公平模式是抢占式的，也就是有可能一个新的获取线程恰好在一个许可证释放时得到了这个许可证，而前面还有等待的线程。
显然使用非公平的模式性能更高，因为它会把许可证发放给刚好准备好的线程，而不用再根据先后顺序去“叫号”了。

使用公平模式

当然，也可以手动选择使用公平模式来运行 Semaphore，Semaphore 提供了两个构造函数，源码如下：

  1. public Semaphore(int permits) {
  2.     sync = new NonfairSync(permits);
  3. }
  4. public Semaphore(int permits, boolean fair) {
  5.     sync = fair ? new FairSync(permits) : new NonfairSync(permits);
  6. }

如果想用公平模式就可以使用第二个构造函数 Semaphore(int permits, boolean fair)，将 fair 值设置为 true 就是公平模式来获取证书了。

其他补充

还提供了一些其他方法，用于实现更多的功能，详情如下：

  • int availablePermits()：返回此信号量中当前可用的许可证数。
  • int getQueueLength()：返回正在等待获取许可证的线程数。
  • boolean hasQueuedThreads()：是否有线程正在等待获取许可证。
  • boolean isFair()：查询 Semaphore 使用的是公平模式还是非公平模式，如果此信号量使用的是公平模式则返回 true。
  • void release(int permits)：释放给定数量的许可证，将其返回到信号量。
  • tryAcquire()：从这个信号量获得许可证，只有在调用时可以使用该许可证。
  • tryAcquire(int permits)：从这个信号量获取给定数量的许可证，只有在调用时全部可用。
  • tryAcquire(int permits, long timeout, TimeUnit unit)：从该信号量获取给定数量的许可证，如果在给定的等待时间内全部可用，并且当前线程尚未 interrupted。
  • tryAcquire(long timeout, TimeUnit unit)：如果在给定的等待时间内可用，并且当前线程尚未到达 interrupted，则从该信号量获取许可。
  • void reducePermits(int reduction) ：减少可用的许可证数量 reduction 个，它是 protected 方法。
  • Collection getQueuedThreads() ：返回所有等待获取许可证的线程集合，它是 protected 方法。

    总结

    Semaphore 信号量是用来管理一组证书的，默认情况下它采取的是非公平的方式来管理证书，这样做的目的是为了实现高性能。Semaphore 中包含了两个重要的方法：release() 方法发布一个许可证书；acquire() 方法阻塞并等待一个证书。当线程调用了 acquire() 方法只有拥有了证书才能继续执行，因此可以使用 Semaphore 来实现限流。