1. AQS 原理

1.1 概述

全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架

特点：

• 用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个生态，控制如何获取锁和释放锁
  • getState - 获取 state 状态
  • setState - 设置 state 状态
  • compareAndSetState - cas 机制设置 state 状态
  • 独占模式是只有一个线程能够访问资源，类似于 Monitor 的 EntryList
• 提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList
• 条件变量来实现等待、唤醒机制，支持多个条件，类似于 Monitor 的 WaitSet

子类主要实现这样一些方法 （默认抛出UnsupportedOperationException）

• tryAcquire
• tryRelease
• tryAcquireShared
• tryReleaseShared
• isHeldExclusively

获取锁的姿势

// 如果获取锁失败
if (!tryAcquire(arg)) {// 入队，可以选择阻塞当前线程  park unpark
}

释放锁的姿势

// 如果释放锁成功
if (tryRelease(arg)) {// 让阻塞线程继续运行
}

1.2 实现不可重入锁

自定义同步器

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;/*** 自定义同步器* @author 晓风残月Lx* @date 2023/4/5 21:44*/
public final class MySync extends AbstractQueuedSynchronizer {@Overrideprotected boolean tryAcquire(int acquires) {if (acquires == 1) {if (compareAndSetState(0, 1)){setExclusiveOwnerThread(Thread.currentThread());return true;}}return false;}@Overrideprotected boolean tryRelease(int acquires) {if (acquires == 1) {if (getState() == 0) {throw new IllegalMonitorStateException();}setExclusiveOwnerThread(null);setState(0);return true;}return false;}protected Condition newCondition() {return new ConditionObject();}@Overrideprotected boolean isHeldExclusively() {return getState() == 1;}
}

自定义锁

有了自定义同步器，很容易复用 AQS ，实现一个功能完备的自定义锁

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;/*** 自定义锁* @author 晓风残月Lx* @date 2023/4/5 21:43*/
public class MyLock implements Lock {static MySync sync = new MySync();@Override// 尝试，不成功，进入等待队列public void lock() {sync.acquire(1);}@Override// 尝试，不成功，进入等待队列，可打断public void lockInterruptibly() throws InterruptedException {sync.acquireInterruptibly(1);}@Override// 尝试一次，不成功返回，不进入队列public boolean tryLock() {return sync.tryAcquire(1);}@Override// 尝试，不成功，进入等待队列，有时限public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {return sync.tryAcquireNanos(1, unit.toNanos(time));}@Override// 释放锁public void unlock() {sync.release(1);}@Override// 生成条件变量public Condition newCondition() {return sync.newCondition();}
}

测试

import com.lv.juc.util.Sleeper;
import lombok.extern.slf4j.Slf4j;/*** @author 晓风残月Lx* @date 2023/4/5 21:53*/
@Slf4j
public class MyLockTest {public static void main(String[] args) {MyLock lock = new MyLock();new Thread(() -> {lock.lock();try {log.debug("locking |...");//lock.lock();//log.debug("locking 2|...");Sleeper.sleep(1);} finally {log.debug("unlocking ...");lock.unlock();}}, "t1").start();new Thread(() -> {lock.lock();try {log.debug("locking |...");Sleeper.sleep(1);} finally {log.debug("unlocking ...");lock.unlock();//lock.unlock();}}, "t2").start();}
}

测试不可重入的话，把注释都去掉

1.3 心得

起源

早期程序员会自己通过一种同步器去实现另一种相近的同步器，例如用可重入锁去实现信号量，或反之。这显然不 够优雅，于是在 JSR166（java 规范提案）中创建了 AQS，提供了这种通用的同步器机制。

目标

AQS 实现的功能目标

• 阻塞版本获取锁 acquire 和 非阻塞的版本尝试获取锁 tryAcquire
• 获取锁超时机制
• 通过打断取消机制
• 独占机制及共享机制
• 条件不满足时的等待机制

设计

获取锁的逻辑

while(state 状态不允许获取) {if (队列中还没有此线程) {入队并阻塞}
}
当前线程出队

释放锁的逻辑

if (state 状态允许了) {恢复阻塞的线程（s）
}

要点

1. 原子维护 state 状态
2. 阻塞及恢复线程
3. 维护队列

1） state 设计

• state 使用 volatile 配合 cas 保证其修改时的原子性
• state 使用了 32 bit int 来维护同步状态，因为当时使用 long 在很多平台测试的结果并不理想

2）阻塞恢复设计

• 早期的控制线程暂停和恢复的 api 有 suspend 和 resume，但它们是不可用的，因为如果先调用的 resume 那么 suspend 将感知不到
• 解决方法是使用 park & unpark 来实现线程的暂停和恢复，先 unpark 再 park 也没问题
• park & unpark 是针对线程的，而不是针对同步器，因此控制粒度更为精细
• park 线程还可以通过 interrupt 打断

3）队列设计

• 使用了 FIFO 先入先出队列，并不支持优先级队列
• 设计时借鉴了 CLH 队列，它是一种单向无锁队列

队列中有 head 和 tail 两个指针节点，都用 volatile 修饰配合 cas 使用，每个节点有 state 维护节点状态

入队伪代码，只需要考虑 tail 赋值的原子性

do {// 原来的 tailNode prev = tail;// 用 cas 在原来 tail 的基础上改为 node
} while(tail.compareAndSet(prev, node))

出队伪代码

// prev 是上一个节点
while((Node prev=node.prev).state != 唤醒状态) {
}
// 设置头节点
head = node;

CLH 好处：

• 无锁，使用自旋
• 快速，无阻塞

AQS 在一些方面改进了 CLH

    private Node enq(final Node node) {for (;;) {Node t = tail;// 队列中还没有元素 tail 为 nullif (t == null) { // Must initializeif (compareAndSetHead(new Node()))tail = head;} else {// 将 node 的 prev 设置为原来的 tailnode.prev = t;// 将 tail 从原来的 tail 设置为 nodeif (compareAndSetTail(t, node)) {// 原来 tail 的 next 设置为 nodet.next = node;return t;}}}}

AQS的并发工具类有