java信号处理相关的库 java信号量使用场景

Semaphore(信号量) 为多线程协作提供了更为强大的的控制方法，前面的文章中，我们学习了synchronized和重入锁ReentrantLock，这2种锁一次只能允许一个线程访问资源，而信号量可以控制有多个线程可以访问特定的资源。

---

Semaphore常用场景：限流

举个🌰：

比如有个停车场，有5个空位，门口有门卫，手中有5把钥匙分别对应5个车位上的锁。来一辆车，门卫会给司机一把钥匙，然后进去找到对应的车位停下来，出去的时候司机将钥匙归还给门卫。停车场生意比较好，同时来了100辆车，但门卫手中只有5把钥匙，同时只能放5辆车进入，其他车只能等待，等有人将钥匙归还给门卫后，才能让其他车辆进入。

上面的例子中门卫就相当于Semaphore，车钥匙就相当于许可证，车就相当于线程。

---

Semaphore主要方法

Semaphore(int permit) : 构造方法，参数表示许可证数量，用来创建信号量

Semaphore(int permit,boolean fair) : 构造方法，当fair等于true时，创建具有给定许可数的信号量并设置为公平信号量

void acquire() throws InterruptedException: 从信号量获取1个许可前，线程将一直阻塞，相当于一辆车占了一个车位，此方法会响应线程中断，表示调用线程的interrupt方法，会使该方法抛出InterruptedException异常

void acquire(int permit) throws InterrupedException：和acquire方法类似，参数表示需要获取许可的数量；比如一个大卡车要入停车站，由于车比较大，需要申请3个车位才可以停放。

void acquireUinterruptibly(int permit)：和acuqire()类似，只是不响应中断。

boolen tryAcquire()：尝试获取许可，不管是否能够获取成功，都立即返回，true表示获取成功，false表示获取失败。

boolean tryAcquire(int permits)：和tryAcqiure()类似，表示尝试获取permits个许可

boolean tryAcquire(long timeout,TimeUnit unit) throws InterruptedException：尝试在指定的时间内获取一个许可，获取成功返回true，指定的时间过后还是无法获取许可，返回false

boolean tryAcquire(int permits, long timeou , TimeUnit unit) throws InterruptedException ：和上一个方法类似，多了一个参数，表示尝试获取permits个许可

void release()：释放一个许可，将其返回给信号量，相当于停车场出去时将钥匙归还给门卫

void release(int n) : 释放n个许可

int availablePermits() : 当前可用的许可数

---

示例一：Semaphore的简单实用：

package aboutThread.Concurrent.Day15;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class Demo1 {
    static Semaphore semaphore = new Semaphore(2);

    public static class T extends Thread {
        public T(String name) {
            super(name);
        }

        @Override
        public void run() {
            Thread thread = Thread.currentThread();
            try {
                semaphore.acquire();
                System.out.println(System.currentTimeMillis() + "," + thread.currentThread().getName() + " 获取许可！");
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                semaphore.release();
                System.out.println(System.currentTimeMillis() + "," + thread.currentThread().getName() + " 释放许可！");
            }
        }

        
    }


    public static void main(String[] args){
        for (int i = 0; i < 10; i++) {
            new T("t_1" + i).start();
        }
    }
}

1590716995080,t_11 获取许可！
1590716995080,t_12 获取许可！
1590716998082,t_12 释放许可！
1590716998082,t_16 获取许可！
1590716998082,t_10 获取许可！
1590716998082,t_11 释放许可！
1590717001082,t_16 释放许可！
1590717001082,t_18 获取许可！
1590717001082,t_13 获取许可！
1590717001082,t_10 释放许可！
1590717004086,t_13 释放许可！
1590717004086,t_14 获取许可！
1590717004086,t_17 获取许可！
1590717004086,t_18 释放许可！
1590717007087,t_14 释放许可！
1590717007087,t_15 获取许可！
1590717007087,t_19 获取许可！
1590717007087,t_17 释放许可！
1590717010088,t_15 释放许可！
1590717010088,t_19 释放许可！

代码中new Semaphore(2) 创建了许可数量为2的信号量，每个线程获取1个许可，同时允许两个线程获取许可，从输出中也可以看出，同时有两个线程可以获取许可，其他线程需要等待已获取许可的线程释放许可之后才能运行。为获取到许可的线程会阻塞在aquire() 方法上，直到获取到许可才能继续。

---

示例二： 获取许可后不释放

门卫（Semaphore)有点呆，司机进去的时候给了钥匙，出来的时候不归还，门卫也不会说什么。最终结果就是其他车辆都无法进入了。

如下代码：

package aboutThread.Concurrent.Day15;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class Demo2 {
    static Semaphore semaphore = new Semaphore(2);

    public static class T extends Thread {
        public T(String name) {
            super(name);
        }

        @Override
        public void run() {
           Thread thread = Thread.currentThread();
           try {
               semaphore.acquire();
               System.out.println(System.currentTimeMillis() + "," + thread.getName() + " 获取许可！");
               TimeUnit.SECONDS.sleep(3);
               System.out.println(System.currentTimeMillis() + "," + thread.getName() + " 运行结束！");
               System.out.println(System.currentTimeMillis() + "," + thread.getName() + "，当前可用许可数量" + semaphore.availablePermits());
           } catch (InterruptedException e) {
                e.printStackTrace();
           } 
        }

        
    }
    public static void main(String[] args) throws InterruptedException{
        for (int i = 0; i < 10; i++) {
            new  T("t_"+i).start();
        }
    }
}

输出：

1590718414710,t_2 获取许可！
1590718414710,t_0 获取许可！
1590718417715,t_0 运行结束！
1590718417715,t_2 运行结束！
1590718417715,t_0，当前可用许可数量0
1590718417715,t_2，当前可用许可数量0

上面程序运行之后一直无法结束，观察一下代码，代码中获取许可之后，没有释放许可的代码，最终导致可用许可为0，其他线程无法获取许可，会在Semaphore.acquire();处等待，导致程序无法结束。

---

示例三：释放许可的正确姿势

示例一种，在finally里释放锁，会有问题吗？

如果获取锁的过程中发生了异常，导致获取锁失败，最后的finally里面也释放了许可，最终会怎样？导致许可数量凭空增长了。

示例代码：

package aboutThread.Concurrent.Day15;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class Demo3 {
    static Semaphore semaphore = new  Semaphore(1);

    public static class T extends Thread{
        public T(String name){
            super(name);
        }

        @Override
        public void run(){
            Thread thread = Thread.currentThread();
            try {
                semaphore.acquire();
                System.out.println(System.currentTimeMillis() + " , " + thread.getName() + " 获取许可！, 当前可用许可数量：" + semaphore.availablePermits());
                //休眠100秒
                TimeUnit.SECONDS.sleep(100);
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + "，运行结束！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally{
                semaphore.release();
            }
            System.out.println(System.currentTimeMillis() + "," + thread.getName() + ", 当前可用许可数量：" + semaphore.availablePermits());
        }
    }

    public static void main(String[] args) throws InterruptedException{
        T t1 = new  T("t1");
        t1.start();
        //休眠1秒
        TimeUnit.SECONDS.sleep(1);
        T t2 = new T("t2");
        t2.start();
        //休眠1秒
        TimeUnit.SECONDS.sleep(1);
        T t3 = new T("t3");
        t3.start();

        //给t2、t3发送中断信号
        t2.interrupt();
        t3.interrupt();
    }
}

输出：

1590719733972 , t1 获取许可！, 当前可用许可数量：0
java.lang.InterruptedException
        at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1040)
        at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1345)
        at java.base/java.util.concurrent.Semaphore.acquire(Semaphore.java:318)
        at aboutThread.Concurrent.Day15.Demo3$T.run(Demo3.java:18)
java.lang.InterruptedException
1590719735978,t2, 当前可用许可数量：1
        at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1343)
        at java.base/java.util.concurrent.Semaphore.acquire(Semaphore.java:318)
        at aboutThread.Concurrent.Day15.Demo3$T.run(Demo3.java:18)
1590719735978,t3, 当前可用许可数量：2

程序中信号量许可数量为1，创建了3个线程获取许可，线程t1获取成功了，然后休眠100秒。其他两个线程阻塞在semaphore.acquire() 方法处，代码中对线程t2、3发送中断信号，我们看一下Semaphore中acquire的源码：

public void acquire() throws InterruptedException

这个方法会响应中断，主线程中对t2、t3发送中断信号之后，acquire()方法会触发InterruptedException异常，t2、t3最终没有获取到许可，但是他们都执行了finally中的释放许可的操作，最后导致许可数量变为了2，导致许可数量增加了。所有程序中释放许可的方式有问题，需要改进一下，获取许可成功才去释放锁。

正确的释放锁的方式：

package aboutThread.Concurrent.Day15;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class Demo4 {
    static Semaphore semaphore = new Semaphore(1);

    public static class T extends Thread{
        public T (String name){
            super(name);
        }

        @Override
        public void run(){
            Thread thread = Thread.currentThread();
            //获取许可是否成功
            boolean acquireSuccess = false;
            try {
                semaphore.acquire();
                acquireSuccess = true;
                System.out.println(System.currentTimeMillis() + "," + thread.getName() +" 获取许可，当前可用许可数量：" + semaphore.availablePermits());
                //休眠100秒
                TimeUnit.SECONDS.sleep(100);
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + " 运行结束，");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally{
                if(acquireSuccess){
                    semaphore.release();
                }
            }
            System.out.println(System.currentTimeMillis() +","+thread.getName() + ", 当前许可数量：" + semaphore.availablePermits());
        }
    }
    public static void main(String[] args) throws InterruptedException{ 
        T t1 = new T("t1");
        t1.start();
        //休眠1秒
        TimeUnit.SECONDS.sleep(1);
        T t2 = new T("t2");
        t2.start();
        //休眠1秒
        TimeUnit.SECONDS.sleep(1);
        T  t3 = new T("t3");
        t3.start();

        //给t2、t3发送中断信号
        t2.interrupt();
        t3.interrupt();
    }
}

输出：

1590721536294,t1 获取许可，当前可用许可数量：0
java.lang.InterruptedException
        at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1343)
        at java.base/java.util.concurrent.Semaphore.acquire(Semaphore.java:318)
        at aboutThread.Concurrent.Day15.Demo4$T.run(Demo4.java:20)
1590721538301,t3, 当前许可数量：0
java.lang.InterruptedException
        at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1040)
        at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1345)
        at java.base/java.util.concurrent.Semaphore.acquire(Semaphore.java:318)
        at aboutThread.Concurrent.Day15.Demo4$T.run(Demo4.java:20)
1590721538302,t2, 当前许可数量：0
1590721636294,t1 运行结束，
1590721636294,t1, 当前许可数量：1

程序中增加了一个变量acquireSuccess用来标记获取许可是否成功，在finally中根据这个变量是否为true，来确定是否释放许可。

---

示例四：在规定的时间内希望获取许可

司机来到停车场，发现停车场已经满了，只能在外等待内部的车出来之后才能进去，但是要等多久，他自己不知道，他希望等10分钟，如果还是进不去，就不到这里停车了。

Semaphore内部2个方法可以提供超时获取许可的功能:

public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException

public boolean tryAcquire(int permits,long timeout, TimeUnit unit) throws InterruptedException

在指定的时间内去尝试获取许可，如果能够获取到，返回true，获取不到返回false。

示例代码：

package aboutThread.Concurrent.Day15;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class Demo5 {
    static Semaphore semaphore = new Semaphore(1);

    public static class T extends Thread{
        public T(String name){
            super(name);
        }

        @Override
        public void run(){
            Thread thread = Thread.currentThread();
            //获取许可是否成功
            boolean acquireSuccess = false;

            try {
                //尝试在1秒内获取许可，获取成功返回true，否则返回false
                System.out.println(System.currentTimeMillis() + "," + thread.getName() + " 尝试获取许可！当前可用许可数量：" + semaphore.availablePermits());
                acquireSuccess = semaphore.tryAcquire(1, TimeUnit.SECONDS);
                //获取成功获取业务代码
                if(acquireSuccess){
                    System.out.println(System.currentTimeMillis() + "," + thread.getName() + " 获取许可成功，当前可用许可数量：" + semaphore.availablePermits());
                    //休眠
                    TimeUnit.SECONDS.sleep(5);
                }else{
                    System.out.println(System.currentTimeMillis() + "," + thread.getName() +  " ,获取许可失败，当前可用许可数量：" + semaphore.availablePermits());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                if(acquireSuccess){
                    semaphore.release();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
        T  t1 = new T("t1");
        t1.start();

        //休眠1秒
        TimeUnit.SECONDS.sleep(1);

        T t2 = new T("t2");
        t2.start();

        //休眠1秒
        TimeUnit.SECONDS.sleep(1);

        T t3 = new T("t3");
        t3.start();

    }

}

输出：

1590736232990,t1 尝试获取许可！当前可用许可数量：1
1590736232991,t1 获取许可成功，当前可用许可数量：0
1590736233995,t2 尝试获取许可！当前可用许可数量：0
1590736234997,t2 ,获取许可失败，当前可用许可数量：0
1590736234997,t3 尝试获取许可！当前可用许可数量：0
1590736236001,t3 ,获取许可失败，当前可用许可数量：0

代码中许可数量为1，semaphore.tryAcquire(1,TimeUnit.SECONDS); : 表示尝试在1秒内获取许可，获取成功立即返回true，超过1秒还是获取不到，返回false。线程t1获取许可成功，之后休眠5秒，从输出中可以看出t2和t3都尝试了1秒，获取失败。

---

其他一些说明

1. Semaphore默认创建的是非公平的信号量？什么意思呢？这个涉及到公平与非公平。举个例子，5个车位，允许5个车辆进去，来了100辆车，只能进5辆，其他95辆在外面排队等着。里面广告出来了1辆车，此时刚好又来了10辆，这10辆车是直接插队到其他95两前面去，还是95两后面去排队呢？让新来的去排队就表示公平，直接去插队争抢第一个，就表示不公平。对于停车场，排队肯定更好一些。不过对于信号量来说不公平的效率更高一些，所以默认是不公平的。
2. 建议阅读以下Semaphore源码，对常用的方法有个了解，不需要都记住，用的时候方便查询就好。
3. 方法中带有throws InterruptedException 声明的，表示这个方法会响应线程中断信号，什么意思？表示调用线程的interrupte()方法后，会让这些方法触发InterruptedException异常，即使这些方法处于阻塞状态，也会立即返回，并抛出InterruptedException异常，线程中断信号也会被清除。

---

这是Java高并发学习的第15天，加油！