全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架
特点：
子类主要实现这样一些方法 （默认抛出UnsupportedOperationException）
获取锁的姿势
// 如果获取锁失败
if (!tryAcquire(arg)) {
// 入队，可以选择阻塞当前线程 park unpark
}
释放锁的姿势
// 如果释放锁成功
if (tryRelease(arg)) {
// 让阻塞线程继续运行
}
自定义同步器
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 {
@Override
protected boolean tryAcquire(int acquires) {
if (acquires == 1) {
if (compareAndSetState(0, 1)){
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
}
return false;
}
@Override
protected 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();
}
@Override
protected 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();
}
}
测试不可重入的话，把注释都去掉
早期程序员会自己通过一种同步器去实现另一种相近的同步器，例如用可重入锁去实现信号量，或反之。这显然不 够优雅，于是在 JSR166（java 规范提案）中创建了 AQS，提供了这种通用的同步器机制。
AQS 实现的功能目标
获取锁的逻辑
while(state 状态不允许获取) {
if (队列中还没有此线程) {
入队并阻塞
}
}
当前线程出队
释放锁的逻辑
if (state 状态允许了) {
恢复阻塞的线程（s）
}
要点
队列中有 head 和 tail 两个指针节点，都用 volatile 修饰配合 cas 使用，每个节点有 state 维护节点状态
入队伪代码，只需要考虑 tail 赋值的原子性
do {
// 原来的 tail
Node 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 为 null
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 将 node 的 prev 设置为原来的 tail
node.prev = t;
// 将 tail 从原来的 tail 设置为 node
if (compareAndSetTail(t, node)) {
// 原来 tail 的 next 设置为 node
t.next = node;
return t;
}
}
}
}
AQS的并发工具类有
