ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

Java高并发专题之15、UC中的Semaphore（信号量）

2022-05-04 20:03:25  阅读：161  来源： 互联网

标签：java 许可 System 信号量 获取 Semaphore 15 public


目录

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

  1. package com.itsoku.chat12;
  3. import java.util.concurrent.Semaphore;
  4. import java.util.concurrent.TimeUnit;
  6. /**
  7.  * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
  8.  */
  9. public class Demo1 {
  10.     static Semaphore semaphore = new Semaphore(2);
  12.     public static class T extends Thread {
  13.         public T(String name) {
  14.             super(name);
  15.         }
  17.         @Override
  18.         public void run() {
  19.             Thread thread = Thread.currentThread();
  20.             try {
  21.                 semaphore.acquire();
  22.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");
  23.                 TimeUnit.SECONDS.sleep(3);
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             } finally {
  27.                 semaphore.release();
  28.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",释放许可!");
  29.             }
  30.         }
  31.     }
  33.     public static void main(String[] args) throws InterruptedException {
  34.         for (int i = 0; i < 10; i++) {
  35.             new T("t-" + i).start();
  36.         }
  37.     }
  38. }

输出：

  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,释放许可!

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

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

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

如下代码：

  1. package com.itsoku.chat12;
  3. import java.util.concurrent.Semaphore;
  4. import java.util.concurrent.TimeUnit;
  6. /**
  7.  * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
  8.  */
  9. public class Demo2 {
  10.     static Semaphore semaphore = new Semaphore(2);
  12.     public static class T extends Thread {
  13.         public T(String name) {
  14.             super(name);
  15.         }
  17.         @Override
  18.         public void run() {
  19.             Thread thread = Thread.currentThread();
  20.             try {
  21.                 semaphore.acquire();
  22.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");
  23.                 TimeUnit.SECONDS.sleep(3);
  24.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
  25.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.         }
  30.     }
  32.     public static void main(String[] args) throws InterruptedException {
  33.         for (int i = 0; i < 10; i++) {
  34.             new T("t-" + i).start();
  35.         }
  36.     }
  37. }

输出：

  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;
  3. import java.util.concurrent.Semaphore;
  4. import java.util.concurrent.TimeUnit;
  6. /**
  7.  * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
  8.  */
  9. public class Demo3 {
  10.     static Semaphore semaphore = new Semaphore(1);
  12.     public static class T extends Thread {
  13.         public T(String name) {
  14.             super(name);
  15.         }
  17.         @Override
  18.         public void run() {
  19.             Thread thread = Thread.currentThread();
  20.             try {
  21.                 semaphore.acquire();
  22.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());
  23.                 //休眠100秒
  24.                 TimeUnit.SECONDS.sleep(100);
  25.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             } finally {
  29.                 semaphore.release();
  30.             }
  31.             System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
  32.         }
  33.     }
  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();
  47.         //给t2和t3发送中断信号
  48.         t2.interrupt();
  49.         t3.interrupt();
  50.     }
  51. }

输出：

  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;
  3. import java.util.concurrent.Semaphore;
  4. import java.util.concurrent.TimeUnit;
  6. /**
  7.  * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
  8.  */
  9. public class Demo4 {
  10.     static Semaphore semaphore = new Semaphore(1);
  12.     public static class T extends Thread {
  13.         public T(String name) {
  14.             super(name);
  15.         }
  17.         @Override
  18.         public void run() {
  19.             Thread thread = Thread.currentThread();
  20.             //获取许可是否成功
  21.             boolean acquireSuccess = false;
  22.             try {
  23.                 semaphore.acquire();
  24.                 acquireSuccess = true;
  25.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());
  26.                 //休眠100秒
  27.                 TimeUnit.SECONDS.sleep(5);
  28.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
  29.             } catch (InterruptedException e) {
  30.                 e.printStackTrace();
  31.             } finally {
  32.                 if (acquireSuccess) {
  33.                     semaphore.release();
  34.                 }
  35.             }
  36.             System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
  37.         }
  38.     }
  40.     public static void main(String[] args) throws InterruptedException {
  41.         T t1 = new T("t1");
  42.         t1.start();
  43.         //休眠1秒
  44.         TimeUnit.SECONDS.sleep(1);
  45.         T t2 = new T("t2");
  46.         t2.start();
  47.         //休眠1秒
  48.         TimeUnit.SECONDS.sleep(1);
  49.         T t3 = new T("t3");
  50.         t3.start();
  52.         //给t2和t3发送中断信号
  53.         t2.interrupt();
  54.         t3.interrupt();
  55.     }
  56. }

输出：

  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;
  3. import java.util.concurrent.Semaphore;
  4. import java.util.concurrent.TimeUnit;
  6. /**
  7.  * 微信公众号：路人甲Java，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
  8.  */
  9. public class Demo5 {
  10.     static Semaphore semaphore = new Semaphore(1);
  12.     public static class T extends Thread {
  13.         public T(String name) {
  14.             super(name);
  15.         }
  17.         @Override
  18.         public void run() {
  19.             Thread thread = Thread.currentThread();
  20.             //获取许可是否成功
  21.             boolean acquireSuccess = false;
  22.             try {
  23.                 //尝试在1秒内获取许可，获取成功返回true，否则返回false
  24.                 System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",尝试获取许可,当前可用许可数量:" + semaphore.availablePermits());
  25.                 acquireSuccess = semaphore.tryAcquire(1, TimeUnit.SECONDS);
  26.                 //获取成功执行业务代码
  27.                 if (acquireSuccess) {
  28.                     System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可成功,当前可用许可数量:" + semaphore.availablePermits());
  29.                     //休眠5秒
  30.                     TimeUnit.SECONDS.sleep(5);
  31.                 } else {
  32.                     System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可失败,当前可用许可数量:" + semaphore.availablePermits());
  33.                 }
  34.             } catch (InterruptedException e) {
  35.                 e.printStackTrace();
  36.             } finally {
  37.                 if (acquireSuccess) {
  38.                     semaphore.release();
  39.                 }
  40.             }
  41.         }
  42.     }
  44.     public static void main(String[] args) throws InterruptedException {
  45.         T t1 = new T("t1");
  46.         t1.start();
  47.         //休眠1秒
  48.         TimeUnit.SECONDS.sleep(1);
  49.         T t2 = new T("t2");
  50.         t2.start();
  51.         //休眠1秒
  52.         TimeUnit.SECONDS.sleep(1);
  53.         T t3 = new T("t3");
  54.         t3.start();
  55.     }
  56. }

输出：

  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. 方法中带有throws InterruptedException声明的，表示这个方法会响应线程中断信号，什么意思？表示调用线程的interrupt()方法，会让这些方法触发InterruptedException异常，即使这些方法处于阻塞状态，也会立即返回，并抛出InterruptedException异常，线程中断信号也会被清除。
来源：http://itsoku.com/course/1/15

标签：java,许可,System,信号量,获取,Semaphore,15,public
来源： https://www.cnblogs.com/konglxblog/p/16222173.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有