AQS原理应用（三）：信号量Semaphore的使用方法

一、基本概念

Semaphore，同样是实现AbstractQueuedSynchronizer（AQS）接口。不同于synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。

二、使用方法

public class SemaphoreTest {

  // 请求的数量
  private static final int threadCount = 10;

  public static void main(String[] args) throws InterruptedException {
    // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
    ExecutorService threadPool = Executors.newFixedThreadPool(10);
    // 一次只能允许执行的线程数量。
    final Semaphore semaphore = new Semaphore(2);

    for (int i = 0; i < threadCount; i++) {
      final int threadnum = i;
      threadPool.execute(() -> {// Lambda 表达式的运用
        try {
          System.out.println("Semaphore acquire start " + threadnum);
          semaphore.acquire(1);// 获取一个许可，所以可运行线程数量为20/1=20
          test(threadnum);
          System.out.println("Semaphore release start " + threadnum);
          semaphore.release(1);// 释放一个许可
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }

      });
    }
    threadPool.shutdown();
    System.out.println("finish");
  }

  public static void test(int threadnum) throws InterruptedException {
    Thread.sleep(1000);// 模拟请求的耗时操作
    System.out.println("Semaphore method run :" + threadnum);
    Thread.sleep(1000);// 模拟请求的耗时操作
  }
}

执行结果：

分析：设定一次只能允许执行的线程数量permits为2，进入test()方法前获取一个许可，执行完test()释放一个许可
（1）一开始所有的线程都会执行，执行到获取许可方法acquire()，所有线程根据可执行线程数判断是否进入阻塞状态
①：如果当前线程执行数小于等于permits，线程通过执行，执行test方法。
②：如果当前线程执行数大于permits，进入阻塞状态
（2）线程0、线程1，在执行中test()过程中，其他线程会发现当前线程执行数大于permits，进入阻塞
(3)当线程0、1执行完test()时，开始执行释放许可方法release()，线程2、3发现当前线程执行数小于permits，开始执行test(),打印出：Semaphore method run :2
…依次循环

三、Semaphore 的公平模式与非公平模式

Semaphore 有两种模式，公平模式和非公平模式。

• 公平模式： 调用 acquire 的顺序就是获取许可证的顺序，遵循 FIFO；
• 非公平模式： 抢占式的。

   public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }