Java高并发 - Semaphore 工具类（高手必会） - 《Java 技术知识》

Semaphore 主要方法
示例 1：Semaphore 简单的使用
示例 2：获取许可之后不释放
示例 3：释放许可正确的姿势
示例 4：在规定的时间内希望获取许可
其他一些使用说明

本文主要内容：掌握 JUC 中一个非常重要的工具类Semaphore。
Semaphore（信号量）为多线程协作提供了更为强大的控制方法，前面的文章中我们学了 synchronized 和重入锁 ReentrantLock，这 2 种锁一次都只能允许一个线程访问一个资源，而信号量可以控制有多少个线程可以同时访问特定的资源。
Semaphore 常用场景：限流
举个例子：
比如有个停车场，有 5 个空位，门口有个门卫，手中 5 把钥匙分别对应 5 个车位上面的锁，来一辆车，门卫会给司机一把钥匙，然后进去找到对应的车位停下来，出去的时候司机将钥匙归还给门卫。停车场生意比较好，同时来了 100 两车，门卫手中只有 5 把钥匙，同时只能放 5 辆车进入，其他车只能等待，等有人将钥匙归还给门卫之后，才能让其他车辆进入。
上面的例子中门卫就相当于 Semaphore，车钥匙就相当于许可证，车就相当于线程。

Semaphore 主要方法

Semaphore(int permits)：构造方法，参数表示许可证数量，用来创建信号量
Semaphore(int permits,boolean fair)：构造方法，当 fair 等于 true 时，创建具有给定许可数的计数信号量并设置为公平信号量
void acquire() throws InterruptedException：从此信号量获取 1 个许可前线程将一直阻塞，相当于一辆车占了一个车位，此方法会响应线程中断，表示调用线程的 interrupt 方法，会使该方法抛出 InterruptedException 异常
void acquire(int permits) throws InterruptedException ：和 acquire()方法类似，参数表示需要获取许可的数量；比如一个大卡车要入停车场，由于车比较大，需要申请 3 个车位才可以停放
void acquireUninterruptibly(int permits) ：和 acquire(int permits) 方法类似，只是不会响应线程中断
boolean tryAcquire()：尝试获取 1 个许可，不管是否能够获取成功，都立即返回，true 表示获取成功，false 表示获取失败
boolean tryAcquire(int permits)：和 tryAcquire()，表示尝试获取 permits 个许可
boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException：尝试在指定的时间内获取 1 个许可，获取成功返回 true，指定的时间过后还是无法获取许可，返回 false
boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException：和 tryAcquire(long timeout, TimeUnit unit)类似，多了一个 permits 参数，表示尝试获取 permits 个许可
void release()：释放一个许可，将其返回给信号量，相当于车从停车场出去时将钥匙归还给门卫
void release(int n)：释放 n 个许可
int availablePermits()：当前可用的许可数
示例 1：Semaphore 简单的使用
package com.itsoku.chat12;

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

/
微信公众号：程序员路人，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo1 {
static Semaphore semaphore = new** Semaphore(2);

**public** **static** **class** **T** **extends** **Thread** {<br />        **public** **T**(String name) {<br />            **super**(name);<br />        }
    @Override<br />        **public** **void** **run**() {<br />            Thread thread = Thread.currentThread();<br />            **try** {<br />                semaphore.acquire();<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");<br />                TimeUnit.SECONDS.sleep(3);<br />            } **catch** (InterruptedException e) {<br />                e.printStackTrace();<br />            } **finally** {<br />                semaphore.release();<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",释放许可!");<br />            }<br />        }<br />    }
**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        **for** (**int** i = 0; i < 10; i++) {<br />            **new** T("t-" + i).start();<br />        }<br />    }<br />}

输出：
1563715791327,t-0,获取许可!
1563715791327,t-1,获取许可!
1563715794328,t-0,释放许可!
1563715794328,t-5,获取许可!
1563715794328,t-1,释放许可!
1563715794328,t-2,获取许可!
1563715797328,t-2,释放许可!
1563715797328,t-6,获取许可!
1563715797328,t-5,释放许可!
1563715797328,t-3,获取许可!
1563715800329,t-6,释放许可!
1563715800329,t-9,获取许可!
1563715800329,t-3,释放许可!
1563715800329,t-7,获取许可!
1563715803330,t-7,释放许可!
1563715803330,t-8,获取许可!
1563715803330,t-9,释放许可!
1563715803330,t-4,获取许可!
1563715806330,t-8,释放许可!
1563715806330,t-4,释放许可!

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

示例 2：获取许可之后不释放

门卫（Semaphore）有点呆，司机进去的时候给了钥匙，出来的时候不归还，门卫也不会说什么。最终结果就是其他车辆都无法进入了。
如下代码：
package com.itsoku.chat12;

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

/
微信公众号：程序员路人，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo2 {
static Semaphore semaphore = new** Semaphore(2);

**public** **static** **class** **T** **extends** **Thread** {<br />        **public** **T**(String name) {<br />            **super**(name);<br />        }
    @Override<br />        **public** **void** **run**() {<br />            Thread thread = Thread.currentThread();<br />            **try** {<br />                semaphore.acquire();<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");<br />                TimeUnit.SECONDS.sleep(3);<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());<br />            } **catch** (InterruptedException e) {<br />                e.printStackTrace();<br />            }<br />        }<br />    }
**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        **for** (**int** i = 0; i < 10; i++) {<br />            **new** T("t-" + i).start();<br />        }<br />    }<br />}

输出：
1563716603924,t-0,获取许可!
1563716603924,t-1,获取许可!
1563716606925,t-0,运行结束!
1563716606925,t-0,当前可用许可数量:0
1563716606925,t-1,运行结束!
1563716606925,t-1,当前可用许可数量:0

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

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

示例 1 中，在 finally 里面释放锁，会有问题么？
如果获取锁的过程中发生异常，导致获取锁失败，最后 finally 里面也释放了许可，最终会怎么样，导致许可数量凭空增长了。
示例代码：
package com.itsoku.chat12;

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

/
微信公众号：程序员路人，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo3 {
static Semaphore semaphore = new** Semaphore(1);

**public** **static** **class** **T** **extends** **Thread** {<br />        **public** **T**(String name) {<br />            **super**(name);<br />        }
    @Override<br />        **public** **void** **run**() {<br />            Thread thread = Thread.currentThread();<br />            **try** {<br />                semaphore.acquire();<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());<br />                //休眠100秒<br />                TimeUnit.SECONDS.sleep(100);<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");<br />            } **catch** (InterruptedException e) {<br />                e.printStackTrace();<br />            } **finally** {<br />                semaphore.release();<br />            }<br />            System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());<br />        }<br />    }
**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T t1 = **new** T("t1");<br />        t1.start();<br />        //休眠1秒<br />        TimeUnit.SECONDS.sleep(1);<br />        T t2 = **new** T("t2");<br />        t2.start();<br />        //休眠1秒<br />        TimeUnit.SECONDS.sleep(1);<br />        T t3 = **new** T("t3");<br />        t3.start();
    //给t2和t3发送中断信号<br />        t2.interrupt();<br />        t3.interrupt();<br />    }<br />}

输出：
1563717279058,t1,获取许可,当前可用许可数量:0
java.lang.InterruptedException
1563717281060,t2,当前可用许可数量:1
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998)
1563717281060,t3,当前可用许可数量:2
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)
at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)
java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)
at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)

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

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

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

/
微信公众号：程序员路人，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo4 {
static Semaphore semaphore = new** Semaphore(1);

**public** **static** **class** **T** **extends** **Thread** {<br />        **public** **T**(String name) {<br />            **super**(name);<br />        }
    @Override<br />        **public** **void** **run**() {<br />            Thread thread = Thread.currentThread();<br />            //获取许可是否成功<br />            **boolean** acquireSuccess = **false**;<br />            **try** {<br />                semaphore.acquire();<br />                acquireSuccess = **true**;<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());<br />                //休眠100秒<br />                TimeUnit.SECONDS.sleep(5);<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");<br />            } **catch** (InterruptedException e) {<br />                e.printStackTrace();<br />            } **finally** {<br />                **if** (acquireSuccess) {<br />                    semaphore.release();<br />                }<br />            }<br />            System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());<br />        }<br />    }
**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T t1 = **new** T("t1");<br />        t1.start();<br />        //休眠1秒<br />        TimeUnit.SECONDS.sleep(1);<br />        T t2 = **new** T("t2");<br />        t2.start();<br />        //休眠1秒<br />        TimeUnit.SECONDS.sleep(1);<br />        T t3 = **new** T("t3");<br />        t3.start();
    //给t2和t3发送中断信号<br />        t2.interrupt();<br />        t3.interrupt();<br />    }<br />}

输出：
1563717751655,t1,获取许可,当前可用许可数量:0
1563717753657,t3,当前可用许可数量:0
java.lang.InterruptedException
1563717753657,t2,当前可用许可数量:0
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)
at com.itsoku.chat12.Demo4$T.run(Demo4.java:23)
java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)
at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)
at com.itsoku.chat12.Demo4$T.run(Demo4.java:23)
1563717756656,t1,运行结束!
1563717756656,t1,当前可用许可数量:1

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

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

司机来到停车场，发现停车场已经满了，只能在外等待内部的车出来之后才能进去，但是要等多久，他自己也不知道，他希望等 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 com.itsoku.chat12;

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

/
微信公众号：程序员路人，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo5 {
static Semaphore semaphore = new** Semaphore(1);

**public** **static** **class** **T** **extends** **Thread** {<br />        **public** **T**(String name) {<br />            **super**(name);<br />        }
    @Override<br />        **public** **void** **run**() {<br />            Thread thread = Thread.currentThread();<br />            //获取许可是否成功<br />            **boolean** acquireSuccess = **false**;<br />            **try** {<br />                //尝试在1秒内获取许可，获取成功返回true，否则返回false<br />                System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",尝试获取许可,当前可用许可数量:" + semaphore.availablePermits());<br />                acquireSuccess = semaphore.tryAcquire(1, TimeUnit.SECONDS);<br />                //获取成功执行业务代码<br />                **if** (acquireSuccess) {<br />                    System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可成功,当前可用许可数量:" + semaphore.availablePermits());<br />                    //休眠5秒<br />                    TimeUnit.SECONDS.sleep(5);<br />                } **else** {<br />                    System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可失败,当前可用许可数量:" + semaphore.availablePermits());<br />                }<br />            } **catch** (InterruptedException e) {<br />                e.printStackTrace();<br />            } **finally** {<br />                **if** (acquireSuccess) {<br />                    semaphore.release();<br />                }<br />            }<br />        }<br />    }
**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br />        T t1 = **new** T("t1");<br />        t1.start();<br />        //休眠1秒<br />        TimeUnit.SECONDS.sleep(1);<br />        T t2 = **new** T("t2");<br />        t2.start();<br />        //休眠1秒<br />        TimeUnit.SECONDS.sleep(1);<br />        T t3 = **new** T("t3");<br />        t3.start();<br />    }<br />}

输出：
1563718410202,t1,尝试获取许可,当前可用许可数量:1
1563718410202,t1,获取许可成功,当前可用许可数量:0
1563718411203,t2,尝试获取许可,当前可用许可数量:0
1563718412203,t3,尝试获取许可,当前可用许可数量:0
1563718412204,t2,获取许可失败,当前可用许可数量:0
1563718413204,t3,获取许可失败,当前可用许可数量:0

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

其他一些使用说明

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

Semaphore 工具类（高手必会）

Semaphore 主要方法

示例 1：Semaphore 简单的使用

示例 2：获取许可之后不释放

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

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

其他一些使用说明