多线程编程-- part 9 信号量:Semaphore
Semaphore简介
Semaphore是一个计数信号量,它的本质是一个"共享锁"。
信号量维护了一个信号量许可集。线程可以通过调用acquire()来获取信号量的许可;当信号量中有可用的许可时,线程能获取该许可;否则线程必须等待,直到有可用的许可为止。 线程可以通过release()来释放它所持有的信号量许可。
Semaphore是通过共享锁实现的。根据共享锁的获取原则,Semaphore分为"公平信号量"和"非公平信号量"。
"公平信号量"和"非公平信号量"的释放信号量的机制是一样的!不同的是它们获取信号量的机制:线程在尝试获取信号量许可时,对于公平信号量而言,如果当前线程不在CLH队列的头部,则排队等候;而对于非公平信号量而言,无论当前线程是不是在CLH队列的头部,它都会直接获取信号量。该差异具体的体现在,它们的tryAcquireShared()函数的实现不同。
Semaphore函数列表
- // 创建具有给定的许可数和非公平的公平设置的 Semaphore。
- Semaphore(int permits)
- // 创建具有给定的许可数和给定的公平设置的 Semaphore。
- Semaphore(int permits, boolean fair)
- // 从此信号量获取一个许可,在提供一个许可前一直将线程阻塞,否则线程被中断。
- void acquire()
- // 从此信号量获取给定数目的许可,在提供这些许可前一直将线程阻塞,或者线程已被中断。
- void acquire(int permits)
- // 从此信号量中获取许可,在有可用的许可前将其阻塞。
- void acquireUninterruptibly()
- // 从此信号量获取给定数目的许可,在提供这些许可前一直将线程阻塞。
- void acquireUninterruptibly(int permits)
- // 返回此信号量中当前可用的许可数。
- int availablePermits()
- // 获取并返回立即可用的所有许可。
- int drainPermits()
- // 返回一个 collection,包含可能等待获取的线程。
- protected Collection<Thread> getQueuedThreads()
- // 返回正在等待获取的线程的估计数目。
- int getQueueLength()
- // 查询是否有线程正在等待获取。
- boolean hasQueuedThreads()
- // 如果此信号量的公平设置为 true,则返回 true。
- boolean isFair()
- // 根据指定的缩减量减小可用许可的数目。
- protected void reducePermits(int reduction)
- // 释放一个许可,将其返回给信号量。
- void release()
- // 释放给定数目的许可,将其返回到信号量。
- void release(int permits)
- // 返回标识此信号量的字符串,以及信号量的状态。
- String toString()
- // 仅在调用时此信号量存在一个可用许可,才从信号量获取许可。
- boolean tryAcquire()
- // 仅在调用时此信号量中有给定数目的许可时,才从此信号量中获取这些许可。
- boolean tryAcquire(int permits)
- // 如果在给定的等待时间内此信号量有可用的所有许可,并且当前线程未被中断,则从此信号量获取给定数目的许可。
- boolean tryAcquire(int permits, long timeout, TimeUnit unit)
- // 如果在给定的等待时间内,此信号量有可用的许可并且当前线程未被中断,则从此信号量获取一个许可。
- boolean tryAcquire(long timeout, TimeUnit unit)
Semaphore数据结构
Semaphore源码分析
(1)公平信号量
- static final class FairSync extends Sync {
- private static final long serialVersionUID = 2014338818796000944L;
- FairSync(int permits) {
- super(permits);
- }
- protected int tryAcquireShared(int acquires) {
- for (;;) {
- if (hasQueuedPredecessors())
- return -1;
- int available = getState();
- int remaining = available - acquires;
- if (remaining < 0 ||
- compareAndSetState(available, remaining))
- return remaining;
- }
- }
- }
(2)非公平信号量
- static final class NonfairSync extends Sync {
- private static final long serialVersionUID = -2694183684443567898L;
- NonfairSync(int permits) {
- super(permits);
- }
- protected int tryAcquireShared(int acquires) {
- return nonfairTryAcquireShared(acquires);
- }
- }
(3)构造函数:默认非公平信号量
- public Semaphore(int permits) {
- sync = new NonfairSync(permits);
- }
- public Semaphore(int permits, boolean fair) {
- sync = fair ? new FairSync(permits) : new NonfairSync(permits);
- }
1.公平信号量的获取和释放
1.1 公平信号量获取
Semaphore中的公平信号量是FairSync。它的获取API如下:

- public void acquire() throws InterruptedException {
- sync.acquireSharedInterruptibly(1);
- }
- public void acquire(int permits) throws InterruptedException {
- if (permits < 0) throw new IllegalArgumentException();
- sync.acquireSharedInterruptibly(permits);
- }

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

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

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

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

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

- private void doAcquireSharedInterruptibly(long arg)
- throws InterruptedException {
- // 创建”当前线程“的Node节点,且Node中记录的锁是”共享锁“类型;并将该节点添加到CLH队列末尾。
- final Node node = addWaiter(Node.SHARED);
- boolean failed = true;
- try {
- for (;;) {
- // 获取上一个节点。
- // 如果上一节点是CLH队列的表头,则”尝试获取共享锁“。
- final Node p = node.predecessor();
- if (p == head) {
- long r = tryAcquireShared(arg);
- if (r >= 0) {
- setHeadAndPropagate(node, r);
- p.next = null; // help GC
- failed = false;
- return;
- }
- }
- // 当前线程一直等待,直到获取到共享锁。
- // 如果线程在等待过程中被中断过,则再次中断该线程(还原之前的中断状态)。
- if (shouldParkAfterFailedAcquire(p, node) &&
- parkAndCheckInterrupt())
- throw new InterruptedException();
- }
- } finally {
- if (failed)
- cancelAcquire(node);
- }
- }

说明: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如下:

- public void release() {
- sync.releaseShared(1);
- }
- public void release(int permits) {
- if (permits < 0) throw new IllegalArgumentException();
- sync.releaseShared(permits);
- }

信号量的releases()释放函数,实际上是调用的AQS中的releaseShared()。
releaseShared()在AQS中实现,源码如下:

- public final boolean releaseShared(int arg) {
- if (tryReleaseShared(arg)) {
- doReleaseShared();
- return true;
- }
- return false;
- }

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

- protected final boolean tryReleaseShared(int releases) {
- for (;;) {
- // 获取“可以获得的信号量的许可数”
- int current = getState();
- // 获取“释放releases个信号量许可之后,剩余的信号量许可数”
- int next = current + releases;
- if (next < current) // overflow
- throw new Error("Maximum permit count exceeded");
- // 设置“可以获得的信号量的许可数”为next。
- if (compareAndSetState(current, next))
- return true;
- }
- }

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

- private void doReleaseShared() {
- for (;;) {
- // 获取CLH队列的头节点
- Node h = head;
- // 如果头节点不为null,并且头节点不等于tail节点。
- if (h != null && h != tail) {
- // 获取头节点对应的线程的状态
- int ws = h.waitStatus;
- // 如果头节点对应的线程是SIGNAL状态,则意味着“头节点的下一个节点所对应的线程”需要被unpark唤醒。
- if (ws == Node.SIGNAL) {
- // 设置“头节点对应的线程状态”为空状态。失败的话,则继续循环。
- if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
- continue;
- // 唤醒“头节点的下一个节点所对应的线程”。
- unparkSuccessor(h);
- }
- // 如果头节点对应的线程是空状态,则设置“文件点对应的线程所拥有的共享锁”为其它线程获取锁的空状态。
- else if (ws == 0 &&
- !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
- continue; // loop on failed CAS
- }
- // 如果头节点发生变化,则继续循环。否则,退出循环。
- if (h == head) // loop if head changed
- break;
- }
- }

说明:doReleaseShared()会释放“共享锁”。它会从前往后的遍历CLH队列,依次“唤醒”然后“执行”队列中每个节点对应的线程;最终的目的是让这些线程释放它们所持有的信号量。
2.非公平信号量的获取和释放
emaphore中的非公平信号量是NonFairSync。在Semaphore中,“非公平信号量许可的释放(release)”与“公平信号量许可的释放(release)”是一样的。
不同的是它们获取“信号量许可”的机制不同
2.1 非公平信号量的获取
非公平信号量的tryAcquireShared()实现如下:
- protected int tryAcquireShared(int acquires) {
- return nonfairTryAcquireShared(acquires);
- }
nonfairTryAcquireShared()的实现如下:

- final int nonfairTryAcquireShared(int acquires) {
- for (;;) {
- // 设置“可以获得的信号量的许可数”
- int available = getState();
- // 设置“获得acquires个信号量许可之后,剩余的信号量许可数”
- int remaining = available - acquires;
- // 如果“剩余的信号量许可数>=0”,则设置“可以获得的信号量许可数”为remaining。
- if (remaining < 0 ||
- compareAndSetState(available, remaining))
- return remaining;
- }
- }

说明:非公平信号量的tryAcquireShared()调用AQS中的nonfairTryAcquireShared()。而在nonfairTryAcquireShared()的for循环中,它都会直接判断“当前剩余的信号量许可数”是否足够;足够的话,则直接“设置可以获得的信号量许可数”,进而再获取信号量。
而公平信号量的tryAcquireShared()中,在获取信号量之前会通过if (hasQueuedPredecessors())来判断“当前线程是不是在CLH队列的头部”,是的话,则返回-1。
Semaphore实例
- public class testHello {
- private static final int SEM_MAX = 10;
- public static void main(String[] args) {
- Semaphore sem = new Semaphore(SEM_MAX);
- //创建线程池
- ExecutorService threadPool = Executors.newFixedThreadPool(3);
- //在线程池中执行任务
- threadPool.execute(new MyThread(sem, 5));
- threadPool.execute(new MyThread(sem, 4));
- threadPool.execute(new MyThread(sem, 7));
- //关闭池
- threadPool.shutdown();
- }
- }
- class MyThread extends Thread {
- private volatile Semaphore sem; // 信号量
- private int count; // 申请信号量的大小
- MyThread(Semaphore sem, int count) {
- this.sem = sem;
- this.count = count;
- }
- public void run() {
- try {
- // 从信号量中获取count个许可
- sem.acquire(count);
- Thread.sleep(2000);
- System.out.println(Thread.currentThread().getName() + " acquire count="+count);
- } catch (InterruptedException e) {
- e.printStackTrace();
- } finally {
- // 释放给定数目的许可,将其返回到信号量。
- sem.release(count);
- System.out.println(Thread.currentThread().getName() + " release " + count + "");
- }
- }
- }
分析:信号量10个许可,1,2线程拿走5,4共9个,sem中剩1个许可,因此3线程处于等待状态,直到前两个释放许可。
多线程编程-- part 9 信号量:Semaphore的更多相关文章
- Java多线程并发工具类-信号量Semaphore对象讲解
Java多线程并发工具类-Semaphore对象讲解 通过前面的学习,我们已经知道了Java多线程并发场景中使用比较多的两个工具类:做加法的CycliBarrier对象以及做减法的CountDownL ...
- 并发编程-concurrent指南-信号量Semaphore
Semaphore翻译成字面意思为 信号量,Semaphore可以控同时访问的线程个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可. acquire( ...
- C#多线程那点事——信号量(Semaphore)
信号量说简单点就是为了线程同步,或者说是为了限制线程能运行的数量. 那它又是怎么限制线程的数量的哩?是因为它内部有个计数器,比如你想限制最多5个线程运行,那么这个计数器的值就会被设置成5,如果一个线程 ...
- windows多线程(八) 信号量Semaphore
如果你看到了这里,我就认为你已经对掌握了有关关键段 CriticalSection.互斥量Mutex和事件Event有关的内容,所以最基本的东西就不再介绍了.如果没有掌握上面说的内容,可以看这里: 关 ...
- python多线程编程—同步原语入门(锁Lock、信号量(Bounded)Semaphore)
摘录python核心编程 一般的,多线程代码中,总有一些特定的函数或者代码块不希望(或不应该)被多个线程同时执行(比如两个线程运行的顺序发生变化,就可能造成代码的执行轨迹或者行为不相同,或者产生不一致 ...
- 并发编程~~~多线程~~~守护线程, 互斥锁, 死锁现象与递归锁, 信号量 (Semaphore), GIL全局解释器锁
一 守护线程 from threading import Thread import time def foo(): print(123) time.sleep(1) print('end123') ...
- Linux多线程编程-信号量
在Linux中.信号量API有两组.一组是多进程编程中的System V IPC信号量.另外一组是我们要讨论的POSIX信号量. 这两组接口类似,但不保证互换.POSIX信号量函数都已sem_开头,并 ...
- Linux下多线程编程-信号量
今天来谈谈线程的同步--信号量. 首先来看看一些概念性的东西: 如进程.线程同步,可理解为进程或线程A和B一块配合,A执行到一定程度时要依靠B的某个结果,于是停下来,示意B运行:B依言执行,再将结果给 ...
- 【C/C++多线程编程之七】pthread信号量
多线程编程之信号量 Pthread是 POSIX threads 的简称.是POSIX的线程标准. 相互排斥量用来处理一个共享资源的同步訪问问题,当有多个共享资源时,就须要 ...
随机推荐
- Nginx OCSP
#开启 vim /path/to/path/conf/nginx.conf ..... events{ ...... 省略..... } http { ..... server{ listen 44 ...
- 关于docker安装、docker镜像、docker容器等
1.Ubuntu安装docker sudo apt install docker.io 注意以下命令需在root下进行 sudo -s 2.查看docker当前容器 docker ps -a 3.启动 ...
- python导入csv文件出现SyntaxError问题分析
python导入csv文件出现SyntaxError问题分析 先简单描述下碰到的题目,要求是写出2个print的结果 可以看到,a指向了一个列表list对象,在Python中,这样的赋值语句,其实内部 ...
- 图片和Base64字符串互转
图片URL转成Base64字符串 /// <summary> /// 通过Url获取到Image格式的文件 /// </summary> /// <param name= ...
- 状态压缩DP:蒙德里安的梦想
代码 #include<bits/stdc++.h> using namespace std; int n,m; long long f[12][1<<11]; bool yy ...
- TensorFlow自编码器(AutoEncoder)之MNIST实践
自编码器可以用于降维,添加噪音学习也可以获得去噪的效果. 以下使用单隐层训练mnist数据集,并且共享了对称的权重参数. 模型本身不难,调试的过程中有几个需要注意的地方: 模型对权重参数初始值敏感,所 ...
- 看我如何通过邮箱获取IP定位-复现
环境准备:一台部署了phpstudy 的vps 脚本内容:get_ip.php 该脚本可以生成一个十分隐蔽的图片,并获取客户端的一些敏感信息. 代码内容如下: <?php //show_sour ...
- PhpMyAdmin提示未加密
新版本的PhpMyAdmin 增强了安全性,需要在配置文件设置一个短语密码.否则进入之后会有“配置文件现在需要一个短语密码.”的红色警叹提示. 解决方法: .将 phpMyAdmin/librarie ...
- webdriervAPI(窗口截图)
from selenium import webdriver driver = webdriver.Chorme() driver.get("http://www.baidu.co ...
- JAVA -数据类型与表达式---表达式
表达式由一个以上的运算符和操作数按一定规则组合而成,通常用于完成计算.计算结果一般是一个数值,但也不一定总是数值.用于计算的操作数可能是数值常量.符号常量.变量或其他某种类型的数据.计算和使用表达式的 ...