信号量Semaphore详解

Semaphore信号量是java中的一个同步器，与CountDownLatch和CyclicBarrier不同的是，它内部的计数器是递增的，并且在一开始初始化Semaphore时可以指定一个初始值，但是并不需要知道需要同步的线程个数，而是在需要同步的地方调用acquire方法时指定需要同步的线程个数。

1、案例1

在主线程中开启两个子线程让它们执行，等所有子线程执行完毕后主线程再继续向下运行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    // 创建一个semaphore实例
    private static Semaphore semaphore = new Semaphore(0);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 将线程A添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread() + "over");
                    semaphore.release();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 将线程B添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread() + "over");
                    semaphore.release();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 等待子线程执行完毕，返回
        semaphore.acquire(3);
        System.out.println("all child thread over");

        // 关闭线程池
        executorService.shutdown();
    }
}

• 如上代码首先创建了一个信号量实例，构造函数的入参为0，说明当前信号量计数器的值为0.然后main函数向线程池添加两个线程任务，在每个线程内部调用信号量的release方法，这相当于让计数器的值增1.
• 最后在main线程里面调用信号量的acquire方法，传参为2说明调用acquire方法的线程会一直阻塞，直到信号量的计数变为2才会返回。
• 如果构造semaphore时传递的参数为N，并在M个线程中调用了该信号量的release方法，那么在调用acquire使M个线程同步时传递的参数应该是M+N.

2、案例2

使用信号量模拟CyclicBarrier复用的功能。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreTest2 {
    // 创建一个semaphore实例
    private static volatile Semaphore semaphore = new Semaphore(0);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 将线程A添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread() + "A task over");
                    semaphore.release();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 将线程B添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread() + "A task over");
                    semaphore.release();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 等待子线程执行任务A完毕，返回
        semaphore.acquire(2);

        // 将线程C添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread() + "B task over");
                    semaphore.release();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 将线程D添加到线程池
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread() + "B task over");
                    semaphore.release();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 等待子线程执行任务B完毕，返回
        semaphore.acquire(2);

        System.out.println("task is over");

        // 关闭线程池
        executorService.shutdown();
    }
}

• 从本例可以看出，Semaphore在某种程度上实现了CyclicBarrier的复用功能.

3、Semaphore主要方法

由该类图可知，Semaphore还是使用AQS实现的。Sync只是对AQS的一个修饰，并且Sync有两个实现类，用来指定获取信号量时是否采用公平策略。

3.1、void acquire()方法

当前线程调用该方法的目的时希望获取一个信号量资源。如果当前信号量个数大于0，则当前信号量的计数会减1，然后该方法直接返回。否则如果当前信号量个数等于0，则当前线程会被放入AQS的阻塞队列。当其他线程调用了当前线程的interrupt()方法中断了当前线程时，则当前线程会抛出InterruptedException异常返回。

3.2、void acquire(int permits)方法

与acquire()方法不同的是，获取permits个信号量。

3.3、void acquireUninterruptibly()方法

该方法与acquire()类似，不同之处在于该方法对中断不响应，也就是当当前线程调用了acquireUninterruptibly获取资源时（包含被阻塞后），其他线程调用了当前线程的interrupt()方法设置了当前线程的中断标志，此时当前线程并不会抛出InterruptedException异常而返回。

3.4、void acquireUninterruptibly(int permits)方法

该方法与acquire(int permits)方法的不同之处在于，该方法对中断不响应。

3.5、void release()方法

该方法的作用是把当前Semaphore对象的信号量值增加1，如果当前有线程因为调用acquire方法被阻塞而被放入了AQS的阻塞队列，则会根据公平策略选择一个信号量个数能被满足的线程进行激活，激活的线程会尝试获取刚增加的信号量。

3.6、void release(int permits)方法

该方法与不带参数的release方法的不同之处在于，前者每次调用会在信号量值原来的基础上增加permits，而后者每次增加1.