Semaphore简介

  Semaphore是一个计数信号量,它的本质是一个"共享锁"。

信号量维护了一个信号量许可集。线程可以通过调用acquire()来获取信号量的许可;当信号量中有可用的许可时,线程能获取该许可;否则线程必须等待,直到有可用的许可为止。 线程可以通过release()来释放它所持有的信号量许可。

  Semaphore是通过共享锁实现的。根据共享锁的获取原则,Semaphore分为"公平信号量"和"非公平信号量"。

  "公平信号量"和"非公平信号量"的释放信号量的机制是一样的!不同的是它们获取信号量的机制:线程在尝试获取信号量许可时,对于公平信号量而言,如果当前线程不在CLH队列的头部,则排队等候;而对于非公平信号量而言,无论当前线程是不是在CLH队列的头部,它都会直接获取信号量。该差异具体的体现在,它们的tryAcquireShared()函数的实现不同。

Semaphore函数列表

  1. // 创建具有给定的许可数和非公平的公平设置的 Semaphore。
  2. Semaphore(int permits)
  3. // 创建具有给定的许可数和给定的公平设置的 Semaphore。
  4. Semaphore(int permits, boolean fair)
  5.  
  6. // 从此信号量获取一个许可,在提供一个许可前一直将线程阻塞,否则线程被中断。
  7. void acquire()
  8. // 从此信号量获取给定数目的许可,在提供这些许可前一直将线程阻塞,或者线程已被中断。
  9. void acquire(int permits)
  10. // 从此信号量中获取许可,在有可用的许可前将其阻塞。
  11. void acquireUninterruptibly()
  12. // 从此信号量获取给定数目的许可,在提供这些许可前一直将线程阻塞。
  13. void acquireUninterruptibly(int permits)
  14. // 返回此信号量中当前可用的许可数。
  15. int availablePermits()
  16. // 获取并返回立即可用的所有许可。
  17. int drainPermits()
  18. // 返回一个 collection,包含可能等待获取的线程。
  19. protected Collection<Thread> getQueuedThreads()
  20. // 返回正在等待获取的线程的估计数目。
  21. int getQueueLength()
  22. // 查询是否有线程正在等待获取。
  23. boolean hasQueuedThreads()
  24. // 如果此信号量的公平设置为 true,则返回 true。
  25. boolean isFair()
  26. // 根据指定的缩减量减小可用许可的数目。
  27. protected void reducePermits(int reduction)
  28. // 释放一个许可,将其返回给信号量。
  29. void release()
  30. // 释放给定数目的许可,将其返回到信号量。
  31. void release(int permits)
  32. // 返回标识此信号量的字符串,以及信号量的状态。
  33. String toString()
  34. // 仅在调用时此信号量存在一个可用许可,才从信号量获取许可。
  35. boolean tryAcquire()
  36. // 仅在调用时此信号量中有给定数目的许可时,才从此信号量中获取这些许可。
  37. boolean tryAcquire(int permits)
  38. // 如果在给定的等待时间内此信号量有可用的所有许可,并且当前线程未被中断,则从此信号量获取给定数目的许可。
  39. boolean tryAcquire(int permits, long timeout, TimeUnit unit)
  40. // 如果在给定的等待时间内,此信号量有可用的许可并且当前线程未被中断,则从此信号量获取一个许可。
  41. boolean tryAcquire(long timeout, TimeUnit unit)

Semaphore数据结构

Semaphore源码分析

(1)公平信号量

  1. static final class FairSync extends Sync {
  2. private static final long serialVersionUID = 2014338818796000944L;
  3.  
  4. FairSync(int permits) {
  5. super(permits);
  6. }
  7.  
  8. protected int tryAcquireShared(int acquires) {
  9. for (;;) {
  10. if (hasQueuedPredecessors())
  11. return -1;
  12. int available = getState();
  13. int remaining = available - acquires;
  14. if (remaining < 0 ||
  15. compareAndSetState(available, remaining))
  16. return remaining;
  17. }
  18. }
  19. }

(2)非公平信号量

  1. static final class NonfairSync extends Sync {
  2. private static final long serialVersionUID = -2694183684443567898L;
  3.  
  4. NonfairSync(int permits) {
  5. super(permits);
  6. }
  7.  
  8. protected int tryAcquireShared(int acquires) {
  9. return nonfairTryAcquireShared(acquires);
  10. }
  11. }

(3)构造函数:默认非公平信号量

  1. public Semaphore(int permits) {
  2. sync = new NonfairSync(permits);
  3. }
  4.  
  5. public Semaphore(int permits, boolean fair) {
  6. sync = fair ? new FairSync(permits) : new NonfairSync(permits);
  7. }

1.公平信号量的获取和释放

1.1 公平信号量获取

Semaphore中的公平信号量是FairSync。它的获取API如下:

  1. public void acquire() throws InterruptedException {
  2. sync.acquireSharedInterruptibly(1);
  3. }
  4.  
  5. public void acquire(int permits) throws InterruptedException {
  6. if (permits < 0) throw new IllegalArgumentException();
  7. sync.acquireSharedInterruptibly(permits);
  8. }

信号量中的acquire()获取函数,实际上是调用的AQS中的acquireSharedInterruptibly()。

acquireSharedInterruptibly()的源码如下:

  1. public final void acquireSharedInterruptibly(int arg)
  2. throws InterruptedException {
  3. // 如果线程是中断状态,则抛出异常。
  4. if (Thread.interrupted())
  5. throw new InterruptedException();
  6. // 否则,尝试获取“共享锁”;获取成功则直接返回,获取失败,则通过doAcquireSharedInterruptibly()获取。
  7. if (tryAcquireShared(arg) < 0)
  8. doAcquireSharedInterruptibly(arg);
  9. }

Semaphore中”公平锁“对应的tryAcquireShared()实现如下:

  1. protected int tryAcquireShared(int acquires) {
  2. for (;;) {
  3. // 是否有比当前线程等待更久的线程
  4. // 若是的话,则返回-1。
  5. if (hasQueuedPredecessors())
  6. return -1;
  7. // 设置“可以获得的信号量的许可数”
  8. int available = getState();
  9. // 设置“获得acquires个信号量许可之后,剩余的信号量许可数”
  10. int remaining = available - acquires;
  11. // 如果“剩余的信号量许可数>=0”,则设置“可以获得的信号量许可数”为remaining。
  12. if (remaining < 0 ||
  13. compareAndSetState(available, remaining))
  14. return remaining;
  15. }
  16. }

说明:tryAcquireShared()的作用是尝试获取acquires个信号量许可数。
对于Semaphore而言,state表示的是“当前可获得的信号量许可数”。

下面看看AQS中doAcquireSharedInterruptibly()的实现:

  1. private void doAcquireSharedInterruptibly(long arg)
  2. throws InterruptedException {
  3. // 创建”当前线程“的Node节点,且Node中记录的锁是”共享锁“类型;并将该节点添加到CLH队列末尾。
  4. final Node node = addWaiter(Node.SHARED);
  5. boolean failed = true;
  6. try {
  7. for (;;) {
  8. // 获取上一个节点。
  9. // 如果上一节点是CLH队列的表头,则”尝试获取共享锁“。
  10. final Node p = node.predecessor();
  11. if (p == head) {
  12. long r = tryAcquireShared(arg);
  13. if (r >= 0) {
  14. setHeadAndPropagate(node, r);
  15. p.next = null; // help GC
  16. failed = false;
  17. return;
  18. }
  19. }
  20. // 当前线程一直等待,直到获取到共享锁。
  21. // 如果线程在等待过程中被中断过,则再次中断该线程(还原之前的中断状态)。
  22. if (shouldParkAfterFailedAcquire(p, node) &&
  23. parkAndCheckInterrupt())
  24. throw new InterruptedException();
  25. }
  26. } finally {
  27. if (failed)
  28. cancelAcquire(node);
  29. }
  30. }

说明:doAcquireSharedInterruptibly()会使当前线程一直等待,直到当前线程获取到共享锁(或被中断)才返回。
(01) addWaiter(Node.SHARED)的作用是,创建”当前线程“的Node节点,且Node中记录的锁的类型是”共享锁“(Node.SHARED);并将该节点添加到CLH队列末尾。
(02) node.predecessor()的作用是,获取上一个节点。如果上一节点是CLH队列的表头,则”尝试获取共享锁“。
(03) shouldParkAfterFailedAcquire()的作用和它的名称一样,如果在尝试获取锁失败之后,线程应该等待,则返回true;否则,返回false。
(04) 当shouldParkAfterFailedAcquire()返回ture时,则调用parkAndCheckInterrupt(),当前线程会进入等待状态,直到获取到共享锁才继续运行。

1.2 公平信号量释放

Semaphore中公平信号量(FairSync)的释放API如下:

  1. public void release() {
  2. sync.releaseShared(1);
  3. }
  4.  
  5. public void release(int permits) {
  6. if (permits < 0) throw new IllegalArgumentException();
  7. sync.releaseShared(permits);
  8. }

信号量的releases()释放函数,实际上是调用的AQS中的releaseShared()。

releaseShared()在AQS中实现,源码如下:

  1. public final boolean releaseShared(int arg) {
  2. if (tryReleaseShared(arg)) {
  3. doReleaseShared();
  4. return true;
  5. }
  6. return false;
  7. }

说明:releaseShared()的目的是让当前线程释放它所持有的共享锁。
它首先会通过tryReleaseShared()去尝试释放共享锁。尝试成功,则直接返回;尝试失败,则通过doReleaseShared()去释放共享锁。

Semaphore重写了tryReleaseShared(),它的源码如下:

  1. protected final boolean tryReleaseShared(int releases) {
  2. for (;;) {
  3. // 获取“可以获得的信号量的许可数”
  4. int current = getState();
  5. // 获取“释放releases个信号量许可之后,剩余的信号量许可数”
  6. int next = current + releases;
  7. if (next < current) // overflow
  8. throw new Error("Maximum permit count exceeded");
  9. // 设置“可以获得的信号量的许可数”为next。
  10. if (compareAndSetState(current, next))
  11. return true;
  12. }
  13. }

如果tryReleaseShared()尝试释放共享锁失败,则会调用doReleaseShared()去释放共享锁。doReleaseShared()的源码如下:

  1. private void doReleaseShared() {
  2. for (;;) {
  3. // 获取CLH队列的头节点
  4. Node h = head;
  5. // 如果头节点不为null,并且头节点不等于tail节点。
  6. if (h != null && h != tail) {
  7. // 获取头节点对应的线程的状态
  8. int ws = h.waitStatus;
  9. // 如果头节点对应的线程是SIGNAL状态,则意味着“头节点的下一个节点所对应的线程”需要被unpark唤醒。
  10. if (ws == Node.SIGNAL) {
  11. // 设置“头节点对应的线程状态”为空状态。失败的话,则继续循环。
  12. if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
  13. continue;
  14. // 唤醒“头节点的下一个节点所对应的线程”。
  15. unparkSuccessor(h);
  16. }
  17. // 如果头节点对应的线程是空状态,则设置“文件点对应的线程所拥有的共享锁”为其它线程获取锁的空状态。
  18. else if (ws == 0 &&
  19. !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
  20. continue; // loop on failed CAS
  21. }
  22. // 如果头节点发生变化,则继续循环。否则,退出循环。
  23. if (h == head) // loop if head changed
  24. break;
  25. }
  26. }

说明:doReleaseShared()会释放“共享锁”。它会从前往后的遍历CLH队列,依次“唤醒”然后“执行”队列中每个节点对应的线程;最终的目的是让这些线程释放它们所持有的信号量。

2.非公平信号量的获取和释放

  emaphore中的非公平信号量是NonFairSync。在Semaphore中,“非公平信号量许可的释放(release)”与“公平信号量许可的释放(release)”是一样的。
不同的是它们获取“信号量许可”的机制不同

2.1 非公平信号量的获取

  

非公平信号量的tryAcquireShared()实现如下:

  1. protected int tryAcquireShared(int acquires) {
  2. return nonfairTryAcquireShared(acquires);
  3. }

nonfairTryAcquireShared()的实现如下:

  1. final int nonfairTryAcquireShared(int acquires) {
  2. for (;;) {
  3. // 设置“可以获得的信号量的许可数”
  4. int available = getState();
  5. // 设置“获得acquires个信号量许可之后,剩余的信号量许可数”
  6. int remaining = available - acquires;
  7. // 如果“剩余的信号量许可数>=0”,则设置“可以获得的信号量许可数”为remaining。
  8. if (remaining < 0 ||
  9. compareAndSetState(available, remaining))
  10. return remaining;
  11. }
  12. }

  说明:非公平信号量的tryAcquireShared()调用AQS中的nonfairTryAcquireShared()。而在nonfairTryAcquireShared()的for循环中,它都会直接判断“当前剩余的信号量许可数”是否足够;足够的话,则直接“设置可以获得的信号量许可数”,进而再获取信号量。
而公平信号量的tryAcquireShared()中,在获取信号量之前会通过if (hasQueuedPredecessors())来判断“当前线程是不是在CLH队列的头部”,是的话,则返回-1。

Semaphore实例

  1. public class testHello {
  2. private static final int SEM_MAX = 10;
  3. public static void main(String[] args) {
  4. Semaphore sem = new Semaphore(SEM_MAX);
  5. //创建线程池
  6. ExecutorService threadPool = Executors.newFixedThreadPool(3);
  7. //在线程池中执行任务
  8. threadPool.execute(new MyThread(sem, 5));
  9. threadPool.execute(new MyThread(sem, 4));
  10. threadPool.execute(new MyThread(sem, 7));
  11. //关闭池
  12. threadPool.shutdown();
  13.  
  14. }
  15. }
  16.  
  17. class MyThread extends Thread {
  18. private volatile Semaphore sem; // 信号量
  19. private int count; // 申请信号量的大小
  20.  
  21. MyThread(Semaphore sem, int count) {
  22. this.sem = sem;
  23. this.count = count;
  24. }
  25.  
  26. public void run() {
  27. try {
  28. // 从信号量中获取count个许可
  29. sem.acquire(count);
  30.  
  31. Thread.sleep(2000);
  32. System.out.println(Thread.currentThread().getName() + " acquire count="+count);
  33. } catch (InterruptedException e) {
  34. e.printStackTrace();
  35. } finally {
  36. // 释放给定数目的许可,将其返回到信号量。
  37. sem.release(count);
  38. System.out.println(Thread.currentThread().getName() + " release " + count + "");
  39. }
  40. }
  41. }

  分析:信号量10个许可,1,2线程拿走5,4共9个,sem中剩1个许可,因此3线程处于等待状态,直到前两个释放许可。

多线程编程-- part 9 信号量:Semaphore的更多相关文章

  1. Java多线程并发工具类-信号量Semaphore对象讲解

    Java多线程并发工具类-Semaphore对象讲解 通过前面的学习,我们已经知道了Java多线程并发场景中使用比较多的两个工具类:做加法的CycliBarrier对象以及做减法的CountDownL ...

  2. 并发编程-concurrent指南-信号量Semaphore

    Semaphore翻译成字面意思为 信号量,Semaphore可以控同时访问的线程个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可. acquire( ...

  3. C#多线程那点事——信号量(Semaphore)

    信号量说简单点就是为了线程同步,或者说是为了限制线程能运行的数量. 那它又是怎么限制线程的数量的哩?是因为它内部有个计数器,比如你想限制最多5个线程运行,那么这个计数器的值就会被设置成5,如果一个线程 ...

  4. windows多线程(八) 信号量Semaphore

    如果你看到了这里,我就认为你已经对掌握了有关关键段 CriticalSection.互斥量Mutex和事件Event有关的内容,所以最基本的东西就不再介绍了.如果没有掌握上面说的内容,可以看这里: 关 ...

  5. python多线程编程—同步原语入门(锁Lock、信号量(Bounded)Semaphore)

    摘录python核心编程 一般的,多线程代码中,总有一些特定的函数或者代码块不希望(或不应该)被多个线程同时执行(比如两个线程运行的顺序发生变化,就可能造成代码的执行轨迹或者行为不相同,或者产生不一致 ...

  6. 并发编程~~~多线程~~~守护线程, 互斥锁, 死锁现象与递归锁, 信号量 (Semaphore), GIL全局解释器锁

    一 守护线程 from threading import Thread import time def foo(): print(123) time.sleep(1) print('end123') ...

  7. Linux多线程编程-信号量

    在Linux中.信号量API有两组.一组是多进程编程中的System V IPC信号量.另外一组是我们要讨论的POSIX信号量. 这两组接口类似,但不保证互换.POSIX信号量函数都已sem_开头,并 ...

  8. Linux下多线程编程-信号量

    今天来谈谈线程的同步--信号量. 首先来看看一些概念性的东西: 如进程.线程同步,可理解为进程或线程A和B一块配合,A执行到一定程度时要依靠B的某个结果,于是停下来,示意B运行:B依言执行,再将结果给 ...

  9. 【C/C++多线程编程之七】pthread信号量

    多线程编程之信号量      Pthread是 POSIX threads 的简称.是POSIX的线程标准.          相互排斥量用来处理一个共享资源的同步訪问问题,当有多个共享资源时,就须要 ...

随机推荐

  1. Nginx OCSP

    #开启 vim  /path/to/path/conf/nginx.conf ..... events{ ...... 省略..... } http { ..... server{ listen 44 ...

  2. 关于docker安装、docker镜像、docker容器等

    1.Ubuntu安装docker sudo apt install docker.io 注意以下命令需在root下进行 sudo -s 2.查看docker当前容器 docker ps -a 3.启动 ...

  3. python导入csv文件出现SyntaxError问题分析

    python导入csv文件出现SyntaxError问题分析 先简单描述下碰到的题目,要求是写出2个print的结果 可以看到,a指向了一个列表list对象,在Python中,这样的赋值语句,其实内部 ...

  4. 图片和Base64字符串互转

    图片URL转成Base64字符串 /// <summary> /// 通过Url获取到Image格式的文件 /// </summary> /// <param name= ...

  5. 状态压缩DP:蒙德里安的梦想

    代码 #include<bits/stdc++.h> using namespace std; int n,m; long long f[12][1<<11]; bool yy ...

  6. TensorFlow自编码器(AutoEncoder)之MNIST实践

    自编码器可以用于降维,添加噪音学习也可以获得去噪的效果. 以下使用单隐层训练mnist数据集,并且共享了对称的权重参数. 模型本身不难,调试的过程中有几个需要注意的地方: 模型对权重参数初始值敏感,所 ...

  7. 看我如何通过邮箱获取IP定位-复现

    环境准备:一台部署了phpstudy 的vps 脚本内容:get_ip.php 该脚本可以生成一个十分隐蔽的图片,并获取客户端的一些敏感信息. 代码内容如下: <?php //show_sour ...

  8. PhpMyAdmin提示未加密

    新版本的PhpMyAdmin 增强了安全性,需要在配置文件设置一个短语密码.否则进入之后会有“配置文件现在需要一个短语密码.”的红色警叹提示. 解决方法: .将 phpMyAdmin/librarie ...

  9. webdriervAPI(窗口截图)

    from  selenium  import  webdriver driver  =  webdriver.Chorme() driver.get("http://www.baidu.co ...

  10. JAVA -数据类型与表达式---表达式

    表达式由一个以上的运算符和操作数按一定规则组合而成,通常用于完成计算.计算结果一般是一个数值,但也不一定总是数值.用于计算的操作数可能是数值常量.符号常量.变量或其他某种类型的数据.计算和使用表达式的 ...