AQS
JDK高级并发组件
CyclicBarrier
使用场景：协调多个线程阻塞在某个屏障点，并在指定数量线程全达到屏障点后同时解除阻塞。例如：英雄联盟5V5加载界面，只有全部都达到屏障点才能进游戏。
特点：
- 可循环使用
- 使用Lock.condition实现
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
public static void main(String[] args) throws InterruptedException {
CyclicBarrier barrier = new CyclicBarrier(5, () -> System.out.println("-----------释放--------->"));
for (int i = 0; i < 4; i++) {
new Thread(new ThreadDemo(i, barrier)).start();
}
Thread.sleep(5000);
new Thread(new ThreadDemo(4, barrier)).start();
Thread.sleep(3000);
System.out.println("-----------测试循环，执行第二次--------->");
// 可循环
for (int i = 10; i < 14; i++) {
new Thread(new ThreadDemo(i, barrier)).start();
}
}
}
ThreadDemo implements Runnable {
int id;
CyclicBarrier barrier;
public ThreadDemo(int id, CyclicBarrier barrier) {
this.id = id;
this.barrier = barrier;
}
@Override
public void run() {
System.out.println(String.format("线程 %s 开始 waiting", id));
try {
//线程阻塞到这里，直到十个线程全部到这里
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(String.format("线程 %s 结束 waiting", id));
}
}
运行结果如下：
线程 0 开始 waiting
线程 3 开始 waiting
线程 2 开始 waiting
线程 1 开始 waiting
线程 4 开始 waiting
-----------释放--------->
线程 4 结束 waiting
线程 0 结束 waiting
线程 1 结束 waiting
线程 2 结束 waiting
线程 3 结束 waiting
-----------测试循环，执行第二次--------->
线程 10 开始 waiting
线程 11 开始 waiting
线程 12 开始 waiting
线程 13 开始 waiting
CountdownLatch
使用场景： 使线程阻塞直到指定数量的操作完成。
特点：
- 不可循环使用
- 使用AQS实现
import java.util.concurrent.CountDownLatch;
public class CountdownLatchDemo {
public static void main(String[] args) throws InterruptedException {
int count = 5;
CountDownLatch countDownLatch = new CountDownLatch(5);
for (int i = 0; i < 8; i++) {
new Thread(new ThreadDemo1(i, countDownLatch)).start();
}
Thread.sleep(1000);
for (int i = count -1 ; i >= 0; i--) {
System.out.println(i);
if (i == 0) {
System.out.println("完成倒计时");
}
countDownLatch.countDown();
Thread.sleep(1000);
}
// 再次尝试阻塞
countDownLatch.await();
// 阻塞失败，打印
System.out.println("不可重复，倒计时完成后await不可用，直接执行");
}
}
class ThreadDemo1 implements Runnable {
int id;
CountDownLatch countDownLatch;
public ThreadDemo1(int id, CountDownLatch countDownLatch) {
this.id = id;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
System.out.println(String.format("线程 %s 开始 waiting", id));
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(String.format("线程 %s 结束 waiting", id));
}
}
结果如下：
线程 5 开始 waiting
线程 2 开始 waiting
线程 1 开始 waiting
线程 0 开始 waiting
线程 6 开始 waiting
线程 4 开始 waiting
线程 7 开始 waiting
线程 3 开始 waiting
4
3
2
1
0
完成倒计时
线程 5 结束 waiting
线程 6 结束 waiting
线程 0 结束 waiting
线程 7 结束 waiting
线程 2 结束 waiting
线程 1 结束 waiting
线程 3 结束 waiting
线程 4 结束 waiting
不可重复，倒计时完成后await不可用，直接执行
Process finished with exit code 0
CountDownLatch 与 CyclicBarrier比较
- countDownLatch不可循环使用；
- countDownLatch: 任意多个线程阻塞直到其他线程完成了指定数量的操作；
- cyclicBarrier: 所有线程阻塞直到线程数达到指定数量。
Semaphore（信号量）
使用场景：控制并发资源数量。
特点：
- 不要求持有线程才能释放；
- 不可重入；
- 支持公平&非公平。
reentrantlock可重入，拥有锁的线程去释放。
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
public class SemaphoreDemo {
public static void main(String[] args) {
final int maxAllow = 5;
final Semaphore semaphore = new Semaphore(maxAllow);
AtomicInteger count = new AtomicInteger();
// 该线程用于打印，定时监测count的值
new Thread(new WrapWhile(1000, count), "99").start();
// 启动50个线程进行信号量测试
for (int i = 0; i < 50; i++) {
new Thread(new ThreadDemo2(count, semaphore)).start();
}
}
}
class ThreadDemo2 implements Runnable {
AtomicInteger count;
Semaphore semaphore;
public ThreadDemo2(AtomicInteger count, Semaphore semaphore) {
this.count = count;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
count.getAndIncrement();
Thread.sleep(2000);
count.getAndDecrement();
semaphore.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}
class WrapWhile implements Runnable {
int maxSleepIntervalMills;
AtomicInteger count;
public WrapWhile(int i, AtomicInteger count) {
this.count = count;
this.maxSleepIntervalMills = i;
}
@Override
public void run() {
while (true) {
try {
System.out.println(count.get());
try {
Thread.sleep(maxSleepIntervalMills);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
结果如下：因为只有5个信号量，所以值永远是5。
0
5
5
5
5
5
5
5
5
ReentrantLock
使用场景：严格互斥，同一时间只允许一个线程访问，只有当前线程允许释放。
特点：
- 只有当前线程才能释放，可重入；
- 支持公平&非公平。
ReentrantLock总共有三个内部类如下。
对ReentrantLock操作都转化为对Sync对象的操作，由于Sync继承了AQS，所以基本上都可以转化为对AQS的操作。如将ReentrantLock的lock函数转化为对Sync的lock函数的调用，而具体会根据采用的策略(如公平策略或者非公平策略)的不同而调用到Sync的不同子类。
AbstractQueuedSynchronizer
思考：并发组件的共性
- 阻塞 & 唤醒
- 阻塞/唤醒的逻辑
- 公平 & 非公平：阻塞时可能需要排队
AQS基础
AQS底层使用了模板方法模式。
阻塞 & 唤醒
LockSupport.park() & LockSupport.unpark();
- 底层使用pthread_cond_timedwait & pthread_cond_signal实现
原子变量
int state; 标识是否获取和释放锁。
AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。
private volatile int state;//共享变量，使用volatile修饰保证线程可见性
以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0(即释放锁)为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的(state会累加)，这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。
公平和非公平：CLH队列
CLH队列实现是一个双向链表，每一个节点都是一个线程。head头节点不阻塞，其他队列中的节点都是阻塞的。
AbstractQueuedSynchronizer类底层的数据结构是使用CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列(虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系)。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点(Node)来实现锁的分配。其中Sync queue，即同步队列，是双向链表，包括head结点和tail结点，head结点主要用作后续的调度。
- 在没有高级同步api帮助下如何保证同步安全操作？ for + cas
- 每个节点对应一个线程；
- waitStatus : 该节点等待状态，用CAS 修改；
- Dummy header – header节点对应的线程非阻塞。
每个线程被阻塞的线程都会被封装成一个Node结点，放入队列。每个节点包含了一个Thread类型的引用，并且每个节点都存在一个状态waitStatus，具体状态如下。
- CANCELLED，值为1，表示当前的线程被取消。 （timeout / interrupt）
- SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，需要进行unpark操作。 （后一个node将会block,当前节点relase/cancel时需要unpark后一个节点）
- CONDITION，值为-2，表示当前节点在等待condition，也就是在condition queue中。
- PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行。 （在shared模式下使用, 因为可能需要release多个后续节点）
- 值为0，表示当前节点在sync queue中，等待着获取锁。
CAS
Unsafe.compareAndSwapXX(); 底层使用cmpxchg实现。
重点：
- 自旋乐观锁；
- linux底层实现：lock cmpxchg， cmpxchg本身不是原子性，多核需要加lock辅助
- API： compareAndSetXX(field, expect, new);
核心API
AQS使用模板方法模式。
- acquire: tryAcquire()，如果失败则入queue, 自旋park，成功则更新head；
- release: tryRelease()，如果成功（一般都成功), unpark后继节点；
- acquireShared: tryAcquireShared()，如果失败入queue，自旋park；
- releaseShared，如果成功（一般都成功), 级联unpark后继节点。
自定义同步器时需要重写AQS提供的模板方法（根据shared[共享]/exclusive[独占]选其一）：
isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。
所以exclusive 和 shared模式最大的不同就是shared模式下，可能需要unpark后续n个节点而exclusive只用一个。
AcquireShared
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
/**
* Acquires in shared uninterruptible mode.
* @param arg the acquire argument
*/
private void doAcquireShared(int arg) {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
}
AQS template pattern
如何使用AQS？
- 创建一个AQS子类，一般起名为sync
- 根据是shared还是exclusive选择实现sync中对应API
- 根据业务逻辑选择当前并发工具类的API对应sync的API
Reentrantlock的实现
-
State:
- 0 无锁
- 1 有锁
-
可重入控制
exclusiveOwnerThread -
公平&非公平：
-
公平： 直接尝试CAS state
-
非公平：如果队列中有前趋节点，则直接失败
-
Condition
- await : 放入condition queue
- signal: 将node 从condition queue 移动到 sync queue
Condition
Condtion 使用另一个queue: conditon queue
Await:将节点加入到condition queue 并park
Signal/signalAll:将节点从condition queue移动到sync queue
Await 必须在循环判断中使用
统一理解
| ReentrantLock | CountDownLatch | Semaphore |
|---|---|---|
| state | 0 未被占用，1占用 | N 还需要倒计时n次 |
| mode | exclusive | shared |
| API | acquire & release | acquireShared & releaseShared |
| 核心逻辑 | 初始state=0, 如果state=0且 cas成功则acquire成功 | 初始state=N, 直到state==0 acquire 成功 countDown 就是 state -1 |
总结
- AQS 使用clh队列支持公平性
- AQS 使用park/unpark来阻塞／唤醒线程
- AQS 使用state字段管理阻塞逻辑
扫一扫
166万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
