java高并发系列 - 第15天:JUC中的Semaphore(信号量)

java高并发系列第15篇文章

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简单的使用

 
  1. package com.itsoku.chat12;

  2. import java.util.concurrent.Semaphore;

  3. import java.util.concurrent.TimeUnit;

  4. /**

  5. * 微信公众号:路人甲Java,专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等),喜欢请关注!

  6. */

  7. public class Demo1 {

  8. static Semaphore semaphore = new Semaphore(2);

  9. public static class T extends Thread {

  10. public T(String name) {

  11. super(name);

  12. }

  13. @Override

  14. public void run() {

  15. Thread thread = Thread.currentThread();

  16. try {

  17. semaphore.acquire();

  18. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");

  19. TimeUnit.SECONDS.sleep(3);

  20. } catch (InterruptedException e) {

  21. e.printStackTrace();

  22. } finally {

  23. semaphore.release();

  24. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",释放许可!");

  25. }

  26. }

  27. }

  28. public static void main(String[] args) throws InterruptedException {

  29. for (int i = 0; i < 10; i++) {

  30. new T("t-" + i).start();

  31. }

  32. }

  33. }

输出:

 
  1. 1563715791327,t-0,获取许可!

  2. 1563715791327,t-1,获取许可!

  3. 1563715794328,t-0,释放许可!

  4. 1563715794328,t-5,获取许可!

  5. 1563715794328,t-1,释放许可!

  6. 1563715794328,t-2,获取许可!

  7. 1563715797328,t-2,释放许可!

  8. 1563715797328,t-6,获取许可!

  9. 1563715797328,t-5,释放许可!

  10. 1563715797328,t-3,获取许可!

  11. 1563715800329,t-6,释放许可!

  12. 1563715800329,t-9,获取许可!

  13. 1563715800329,t-3,释放许可!

  14. 1563715800329,t-7,获取许可!

  15. 1563715803330,t-7,释放许可!

  16. 1563715803330,t-8,获取许可!

  17. 1563715803330,t-9,释放许可!

  18. 1563715803330,t-4,获取许可!

  19. 1563715806330,t-8,释放许可!

  20. 1563715806330,t-4,释放许可!

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

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

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

如下代码:

 
  1. package com.itsoku.chat12;

  2. import java.util.concurrent.Semaphore;

  3. import java.util.concurrent.TimeUnit;

  4. /**

  5. * 微信公众号:路人甲Java,专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等),喜欢请关注!

  6. */

  7. public class Demo2 {

  8. static Semaphore semaphore = new Semaphore(2);

  9. public static class T extends Thread {

  10. public T(String name) {

  11. super(name);

  12. }

  13. @Override

  14. public void run() {

  15. Thread thread = Thread.currentThread();

  16. try {

  17. semaphore.acquire();

  18. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");

  19. TimeUnit.SECONDS.sleep(3);

  20. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");

  21. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());

  22. } catch (InterruptedException e) {

  23. e.printStackTrace();

  24. }

  25. }

  26. }

  27. public static void main(String[] args) throws InterruptedException {

  28. for (int i = 0; i < 10; i++) {

  29. new T("t-" + i).start();

  30. }

  31. }

  32. }

输出:

 
  1. 1563716603924,t-0,获取许可!

  2. 1563716603924,t-1,获取许可!

  3. 1563716606925,t-0,运行结束!

  4. 1563716606925,t-0,当前可用许可数量:0

  5. 1563716606925,t-1,运行结束!

  6. 1563716606925,t-1,当前可用许可数量:0

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

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

示例1中,在finally里面释放锁,会有问题么?

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

示例代码:

 
  1. package com.itsoku.chat12;

  2. import java.util.concurrent.Semaphore;

  3. import java.util.concurrent.TimeUnit;

  4. /**

  5. * 微信公众号:路人甲Java,专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等),喜欢请关注!

  6. */

  7. public class Demo3 {

  8. static Semaphore semaphore = new Semaphore(1);

  9. public static class T extends Thread {

  10. public T(String name) {

  11. super(name);

  12. }

  13. @Override

  14. public void run() {

  15. Thread thread = Thread.currentThread();

  16. try {

  17. semaphore.acquire();

  18. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());

  19. //休眠100秒

  20. TimeUnit.SECONDS.sleep(100);

  21. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");

  22. } catch (InterruptedException e) {

  23. e.printStackTrace();

  24. } finally {

  25. semaphore.release();

  26. }

  27. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());

  28. }

  29. }

  30. public static void main(String[] args) throws InterruptedException {

  31. T t1 = new T("t1");

  32. t1.start();

  33. //休眠1秒

  34. TimeUnit.SECONDS.sleep(1);

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

  36. t2.start();

  37. //休眠1秒

  38. TimeUnit.SECONDS.sleep(1);

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

  40. t3.start();

  41. //给t2和t3发送中断信号

  42. t2.interrupt();

  43. t3.interrupt();

  44. }

  45. }

输出:

 
  1. 1563717279058,t1,获取许可,当前可用许可数量:0

  2. java.lang.InterruptedException

  3. 1563717281060,t2,当前可用许可数量:1

  4. at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998)

  5. 1563717281060,t3,当前可用许可数量:2

  6. at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)

  7. at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)

  8. at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)

  9. java.lang.InterruptedException

  10. at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302)

  11. at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)

  12. at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)

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

 
  1. public void acquire() throws InterruptedException

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

正确的释放锁的方式,如下:

 
  1. package com.itsoku.chat12;

  2. import java.util.concurrent.Semaphore;

  3. import java.util.concurrent.TimeUnit;

  4. /**

  5. * 微信公众号:路人甲Java,专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等),喜欢请关注!

  6. */

  7. public class Demo4 {

  8. static Semaphore semaphore = new Semaphore(1);

  9. public static class T extends Thread {

  10. public T(String name) {

  11. super(name);

  12. }

  13. @Override

  14. public void run() {

  15. Thread thread = Thread.currentThread();

  16. //获取许可是否成功

  17. boolean acquireSuccess = false;

  18. try {

  19. semaphore.acquire();

  20. acquireSuccess = true;

  21. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());

  22. //休眠100秒

  23. TimeUnit.SECONDS.sleep(5);

  24. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");

  25. } catch (InterruptedException e) {

  26. e.printStackTrace();

  27. } finally {

  28. if (acquireSuccess) {

  29. semaphore.release();

  30. }

  31. }

  32. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());

  33. }

  34. }

  35. public static void main(String[] args) throws InterruptedException {

  36. T t1 = new T("t1");

  37. t1.start();

  38. //休眠1秒

  39. TimeUnit.SECONDS.sleep(1);

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

  41. t2.start();

  42. //休眠1秒

  43. TimeUnit.SECONDS.sleep(1);

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

  45. t3.start();

  46. //给t2和t3发送中断信号

  47. t2.interrupt();

  48. t3.interrupt();

  49. }

  50. }

输出:

 
  1. 1563717751655,t1,获取许可,当前可用许可数量:0

  2. 1563717753657,t3,当前可用许可数量:0

  3. java.lang.InterruptedException

  4. 1563717753657,t2,当前可用许可数量:0

  5. at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302)

  6. at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)

  7. at com.itsoku.chat12.Demo4$T.run(Demo4.java:23)

  8. java.lang.InterruptedException

  9. at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998)

  10. at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304)

  11. at java.util.concurrent.Semaphore.acquire(Semaphore.java:312)

  12. at com.itsoku.chat12.Demo4$T.run(Demo4.java:23)

  13. 1563717756656,t1,运行结束!

  14. 1563717756656,t1,当前可用许可数量:1

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

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

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

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

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

  2. public boolean tryAcquire(int permits, long timeout, TimeUnit unit)

  3. throws InterruptedException

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

示例代码:

 
  1. package com.itsoku.chat12;

  2. import java.util.concurrent.Semaphore;

  3. import java.util.concurrent.TimeUnit;

  4. /**

  5. * 微信公众号:路人甲Java,专注于java技术分享(带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等),喜欢请关注!

  6. */

  7. public class Demo5 {

  8. static Semaphore semaphore = new Semaphore(1);

  9. public static class T extends Thread {

  10. public T(String name) {

  11. super(name);

  12. }

  13. @Override

  14. public void run() {

  15. Thread thread = Thread.currentThread();

  16. //获取许可是否成功

  17. boolean acquireSuccess = false;

  18. try {

  19. //尝试在1秒内获取许可,获取成功返回true,否则返回false

  20. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",尝试获取许可,当前可用许可数量:" + semaphore.availablePermits());

  21. acquireSuccess = semaphore.tryAcquire(1, TimeUnit.SECONDS);

  22. //获取成功执行业务代码

  23. if (acquireSuccess) {

  24. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可成功,当前可用许可数量:" + semaphore.availablePermits());

  25. //休眠5秒

  26. TimeUnit.SECONDS.sleep(5);

  27. } else {

  28. System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可失败,当前可用许可数量:" + semaphore.availablePermits());

  29. }

  30. } catch (InterruptedException e) {

  31. e.printStackTrace();

  32. } finally {

  33. if (acquireSuccess) {

  34. semaphore.release();

  35. }

  36. }

  37. }

  38. }

  39. public static void main(String[] args) throws InterruptedException {

  40. T t1 = new T("t1");

  41. t1.start();

  42. //休眠1秒

  43. TimeUnit.SECONDS.sleep(1);

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

  45. t2.start();

  46. //休眠1秒

  47. TimeUnit.SECONDS.sleep(1);

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

  49. t3.start();

  50. }

  51. }

输出:

 
  1. 1563718410202,t1,尝试获取许可,当前可用许可数量:1

  2. 1563718410202,t1,获取许可成功,当前可用许可数量:0

  3. 1563718411203,t2,尝试获取许可,当前可用许可数量:0

  4. 1563718412203,t3,尝试获取许可,当前可用许可数量:0

  5. 1563718412204,t2,获取许可失败,当前可用许可数量:0

  6. 1563718413204,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. 方法中带有 throwsInterruptedException声明的,表示这个方法会响应线程中断信号,什么意思?表示调用线程的 interrupt()方法后,会让这些方法触发 InterruptedException异常,即使这些方法处于阻塞状态,也会立即返回,并抛出 InterruptedException异常,线程中断信号也会被清除。

码子不易,感觉还可以的,帮忙分享一下,谢谢!

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值