信号量Semaphore详解

拼搏现实的明天。 2023-01-08 02:30 166阅读 0赞

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主要方法 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70][]

由该类图可知，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.

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70]: /images/20221119/ca61a2ac8bb245d28d33b354ffcd8af0.png