简介

Semaphore 又名计数信号量,从概念上来讲,信号量初始并维护一定数量的许可证,使用之前先要先获得一个许可,用完之后再释放一个许可。信号量通常用于限制线程的数量来控制访问某些资源,从而达到单机限流的目的,比如SpringCloud 中的Zuul 组件用的是 Hystrix 的信号量(semaphore)隔离模式。

源码分析

重要的内部类

Semaphore 和 ReentrantLock 内部类完全相似, 有3个重要的内部类,分别也是 SyncNonfairSyncFairSync

  1. Sync 是后面两个的父类,继承至AbstractQueuedSynchronizer(AQS)
  2. NonfairSync和FairSync都继承至Sync
  3. NonfairSync 主要用于实现非公平锁,FairSync 主要用于实现公平锁

如果你看了前面几天关于锁的源码分析,是不是发现它们的套路都差不多呢?

重要的属性

和 ReentrantLock 也完全一样,只有一个重要的属性,同步器sync:

private final Sync sync;

两个构造方法

// ①指定初始许可证数量
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
// ②指定初始许可证数量和公平模式
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

两个构造方法最后都是初始化许可证数量,调用的也就是同步器里面的构造方法来初始化AQS 里面的state字段

// Sync 的构造方法
Sync(int permits) {
setState(permits);
} // AQS 中的代码
protected final void setState(int newState) {
state = newState;
}

获取许可:acquire()

默认每次获得1个许可,如果没有可用的许可证会阻塞线程,或者被中断抛出异常。

源码分析:

public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1); // 默认每次获得1个许可
}

acquireSharedInterruptibly(1)会调用 AQS 里面的方法:

public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted()) // 线程被中断,抛出异常
throw new InterruptedException();
if (tryAcquireShared(arg) < 0) // tryAcquireShared 尝试获得许可,返回小于0 表示没有获得许可
doAcquireSharedInterruptibly(arg); // 没有获得许可,排队阻塞
}

tryAcquireShared(arg)方法:

tryAcquireShared 有两种实现,也就是 FairSync(公平模式) 和 NonfairSync(非公平模式) 不同实现。

  1. 公平模式的实现代码 FairSync.tryAcquireShared

    // acquires
    protected int tryAcquireShared(int acquires) {
    for (;;) { // 自旋
    if (hasQueuedPredecessors()) // 检查是否有更早的线程在排队获得许可
    return -1; // 有排队的线程,返回-1,小于0表示获得许可失败
    int available = getState(); // 获得可用许可数
    int remaining = available - acquires; // 减去一个许可,计算剩余的许可数
    if (remaining < 0 || compareAndSetState(available, remaining))
    // remaining < 0 成立的话就说明获取许可失败了,出去也要排队阻塞线程
    return remaining;
    }
    }
  2. 非公平模式的实现代码NonfairSync.tryAcquireShared:

    protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires); // 调用父类Sync里面的实现方法
    }
    // 父类Sync里面的实现方法
    final int nonfairTryAcquireShared(int acquires) {
    for (;;) { // 自旋
    int available = getState(); // 获得可用许可数
    int remaining = available - acquires; // 减去一个许可,计算剩余的许可数
    if (remaining < 0 || compareAndSetState(available, remaining))
    // remaining < 0 成立的话就说明获取许可失败了,出去也要排队阻塞线程
    return remaining;
    }
    }

    有没有发现他们的代码非常相识?公平模式的实现就只是比非公平模式多了一个hasQueuedPredecessors() 方法调用判断,这个方法主要就是检查排队的队列里面是不是还有其他线程。在之前分析ReentrantLock 源码的文章中也有提到。

如果tryAcquireShared 方法没有获得许可(返回值小于0),就会进入到AQS 的 doAcquireSharedInterruptibly 方法:

private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
// 为当前线程创建排队节点,并加入到队列
// addWaiter方法的分析在之前的AQS分析文章已经分析过了
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) { // 自旋,尝试获得许可,阻塞线程,唤醒后继续获得许可
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg); // 尝试获得许可
if (r >= 0) { // 获得许可
setHeadAndPropagate(node, r); // 设置排队的头节点
p.next = null; // help GC
failed = false;
return; // 线程获得许可,退出
}
}
// shouldParkAfterFailedAcquire 如果线程应阻塞,则返回true
// 之前的AQS分析文章已经分析过了
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
// 被中断了,抛出异常
throw new InterruptedException();
}
} finally {
if (failed) // 节点被取消
cancelAcquire(node);
}
}

获得许可总结:

  1. 获得许可就是对初始化的许可证进行减1,直到没有许可证了就会进入到队列排队阻塞线程
  2. 公平模式下,会去看排队的队列是否有更早的线程在排队获取
  3. 非公平模式下,不会去检查排队队列

释放许可:acquire()

默认释放一个许可

public void release() {
sync.releaseShared(1); // 释放一个许可
}

调用的还是AQS框架里面的代码实现:

public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) { // tryReleaseShared 是信号量自己实现的
doReleaseShared();
return true;
}
return false;
}

tryReleaseShared 方法实现:

说明一下,这个释放许可的实现,公平模式和非公平模式都是调用的同一个实现。

protected final boolean tryReleaseShared(int releases) {
for (;;) { // 自旋
int current = getState(); //当前可用的许可
int next = current + releases; // 加上释放的许可
if (next < current) // 以防你传个负的树过来释放
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next)) // CAS 修改,成功就是释放成功,失败的话继续自旋
return true;
}
}

释放许可总结:

  1. 释放许可就是把开始获得的许可还回去
  2. 用到CAS来修改许可证数,用自旋来保证一定会还回去(直到还成功为止)

其他API方法

Semaphore 还有其他的很多API可以调用,但其实源码都差不多,所以这里就不继续分析了,如果你把我之前分析AQS、ReentrantLock、ReentrantReadWriteLock的源码文章也看了,你就会发现这个Semaphore 的源码读起来非常简单了,这里再简单说下其他API的作用。

  1. void acquire(int permits)

    和上面分析的acquire()功能一样,只不过你可以指定获取许可数,源码在减的时候就不是减1了,在释放的时候也要注意,最好保持一致。

    被中断会抛出异常
  2. void acquireUninterruptibly()

    Uninterruptibly(),和 acquire() 方法的唯一区别就是线程被中断了也不会抛出异常,其他完全一致
  3. void acquireUninterruptibly(int permits)

    被中断不抛出异常,指定每次获取许可的数量
  4. boolean tryAcquire()

    只会尝试一次获得许可,获得成功了就返回true,失败了不会去排队阻塞线程。

    还有几个带参数的,意思都差不多。
  5. int availablePermits()

    返回可用的许可数
  6. void release(int permits)

    一次释放指定的许可数

Semaphore 总结

  1. Semaphore 也是基于AQS框架来实现的
  2. Semaphore 也有公平和非公平之说,公平就是在获取许可之前会先看一下队列是否有其他线程在排队
  3. Semaphore 的初始信号量必须指定,如果是1的话,功能就相当于一个互斥锁了
  4. Semaphore 支持重入获得许可,但是这里要注意的是,如果一个线程先获得了许可,没释放又来获得许可,这时候许可数不足的情况下,当前线程会被阻塞,有可能会死锁。
  5. 如果这篇文章没看懂,可以先去看看的之前关于AQS(AQS分析文章里面有一个自己实现的共享锁,和这里的信号量非常相似)、ReentrantLock和RRWLock源码分析的文章,所有文章看完,保证你一懂百懂,奥利给。

源码分析:Semaphore之信号量的更多相关文章

  1. 【JDK】JDK源码分析-Semaphore

    概述 Semaphore 是并发包中的一个工具类,可理解为信号量.通常可以作为限流器使用,即限制访问某个资源的线程个数,比如用于限制连接池的连接数. 打个通俗的比方,可以把 Semaphore 理解为 ...

  2. 【JUC】JDK1.8源码分析之Semaphore(六)

    一.前言 分析了CountDownLatch源码后,下面接着分析Semaphore的源码.Semaphore称为计数信号量,它允许n个任务同时访问某个资源,可以将信号量看做是在向外分发使用资源的许可证 ...

  3. Java并发包中Semaphore的工作原理、源码分析及使用示例

    1. 信号量Semaphore的介绍 我们以一个停车场运作为例来说明信号量的作用.假设停车场只有三个车位,一开始三个车位都是空的.这时如果同时来了三辆车,看门人允许其中它们进入进入,然后放下车拦.以后 ...

  4. Semaphore 源码分析

    Semaphore 源码分析 1. 在阅读源码时做了大量的注释,并且做了一些测试分析源码内的执行流程,由于博客篇幅有限,并且代码阅读起来没有 IDE 方便,所以在 github 上提供JDK1.8 的 ...

  5. 并发编程之 Semaphore 源码分析

    前言 并发 JUC 包提供了很多工具类,比如之前说的 CountDownLatch,CyclicBarrier ,今天说说这个 Semaphore--信号量,关于他的使用请查看往期文章并发编程之 线程 ...

  6. Java - &quot;JUC&quot; Semaphore源码分析

    Java多线程系列--“JUC锁”11之 Semaphore信号量的原理和示例 Semaphore简介 Semaphore是一个计数信号量,它的本质是一个"共享锁". 信号量维护了 ...

  7. 并发编程(七)——AbstractQueuedSynchronizer 之 CountDownLatch、CyclicBarrier、Semaphore 源码分析

    这篇,我们的关注点是 AQS 最后的部分,共享模式的使用.本文先用 CountDownLatch 将共享模式说清楚,然后顺着把其他 AQS 相关的类 CyclicBarrier.Semaphore 的 ...

  8. Spring AMQP 源码分析 02 - CachingConnectionFactory

    ### 准备 ## 目标 了解 CachingConnectionFactory 在默认缓存模式下的工作原理   ## 前置知识   <Spring AMQP 源码分析 01 - Impatie ...

  9. AbstractQueuedSynchronizer源码分析

    AbstractQueuedSynchronizer源码分析 前提 AQS(java.util.concurrent.locks.AbstractQueuedSynchronizer)是并发编程大师D ...

  10. Spark2.1.0之源码分析——事件总线

    阅读提示:阅读本文前,最好先阅读<Spark2.1.0之源码分析——事件总线>.<Spark2.1.0事件总线分析——ListenerBus的继承体系>及<Spark2. ...

随机推荐

  1. 读书笔记--SQL必知必会06--用通配符进行过滤

    6.1 LIKE操作符 通配符(wildcard),用来匹配某些值的的特殊字符. 在搜索子句中必须通过LIKE操作符使用通配符. 通配符搜索只能用于文本字段(字符串),非文本数据类型字段不能使用通配符 ...

  2. U3D自定义Inspector项未触发保存事件的解决方案

    1.问题描述与解决方案 1.1.说明 应该只有起步做U3D编辑器插件的部分同行需要了解本文. 该问题源于在做UI插件的时候,发现Inspector面板上手动修改值后,没有触发U3D编辑器本身的修改事件 ...

  3. Spring编程风格

    给自己使用的无需定义接口:即一个模块内部的都是封装的,定义接口并不会得到很多好处,变过几次实现?? “优先面向接口编程,而非实现” 不是必须,是优先: 给朋友(第三方)使用的定义接口:即要公开的功能, ...

  4. 程序猿的量化交易之路(20)--Cointrader之Assert实体(8)

    转载需说明出处:http://blog.csdn.net/minimicall, http://cloudtrade.top 不论什么可交易的都能够称之为Assert,资产.其类代码例如以下: pac ...

  5. Linux网络管理之net-tools VS iproute2

    查看网卡及IP ifconfig ip link [show] --------- ifconfig -a ip addr show 激活和停止网络接口 ifconfig eth0 up/down i ...

  6. Android视图重绘,使用invalidate还是requestLayout

    概述 在我们在进行自定义View的相关开发中,当我们更改了当前View的状态,比如大小,位置等,我们需要重新刷新整个界面,保证显示最新的状态.在Android中,让当前的视图重绘有两种方式,inval ...

  7. git误commit大文件导致不能push问题解决

    git push时终端报错: error: RPC failed; HTTP 413 curl 22 The requested URL returned error: 413 Request Ent ...

  8. ThreadPoolExecutor源码解析(二)

    1.ThreadPoolExcuter运行实例 首先我们先看如何新建一个ThreadPoolExecutor去运行线程.然后深入到源码中去看ThreadPoolExecutor里面使如何运作的. pu ...

  9. CCF关于NOIP竞赛程序提交的管理规则

    在NOIP复赛中,NOI各省组织单位必须严格遵循CCF<关于NOIP数据提交格式的说明>的规范在竞赛结束后规定时间内向CCF提交本赛区所有参赛选手的程序. 为竞赛的公平以及赛后按时完成竞赛 ...

  10. js基础梳理-究竟什么是执行上下文栈(执行栈),执行上下文(可执行代码)?

    日常在群里讨论一些概念性的问题,比如变量提升,作用域和闭包相关问题的时候,经常会听一些大佬们给别人解释的时候说执行上下文,调用上下文巴拉巴拉,总有点似懂非懂,不明觉厉的感觉.今天,就对这两个概念梳理一 ...