java之AQS(AbstractQueuedSynchronizer)用法解读
作者：夏子曦
AQS是Java并发包中的核心组件,用于构建锁和其他同步器,它通过同步状态管理和FIFO队列实现线程的排队和唤醒机制,AQS支持独占和共享两种资源共享方式,并广泛应用于各种同步器的实现中
AQS（AbstractQueuedSynchronizer）是Java并发包（java.util.concurrent）中的一个核心组件，是构建锁和其他同步器的基础框架。
以下是对AQS的详细理解：
一、AQS的基本概念
AQS，全称为AbstractQueuedSynchronizer，是一个抽象的队列式同步器。
它定义了一套多线程访问共享资源的同步器框架，为Java并发同步组件提供统一的底层支持。
AQS是一个为各个同步组件提供基本框架的抽象类，其内部实现了同步状态的管理和线程的排队机制。
二、AQS的核心组件
- 同步状态：AQS使用一个
int类型的成员变量来表示同步状态。这个状态变量是线程共享的资源，通过内置的FIFO队列（先进先出队列）来完成获取资源线程的排队工作。 - FIFO队列：AQS的底层实现是一个双向链表，用于管理等待获取同步状态的线程。当线程无法获取同步状态时，会被加入到这个队列中等待。
- CLH队列锁：AQS使用CLH队列锁来实现线程的阻塞等待和唤醒机制。CLH是一个虚拟的双向队列，即不存在队列实例，仅存在节点之间的关联关系。
三、AQS的工作原理
- 获取同步状态：当线程尝试获取同步状态时，会调用AQS的
tryAcquire方法（对于独占模式）或tryAcquireShared方法（对于共享模式）。如果成功获取到同步状态，则返回true；否则，线程会被加入到等待队列中。 - 释放同步状态：当线程释放同步状态时，会调用AQS的
tryRelease方法（对于独占模式）或tryReleaseShared方法（对于共享模式）。这些方法会修改同步状态的值，并可能唤醒等待队列中的线程。 - 线程排队与唤醒：等待获取同步状态的线程会被加入到FIFO队列中，并按照队列的顺序等待。当某个线程释放同步状态时，会唤醒队列中的下一个线程来尝试获取同步状态。
四、AQS的资源共享方式
AQS支持两种资源共享方式：独占（Exclusive）和共享（Share）。
- 独占：只有一个线程能执行，如ReentrantLock。独占锁又可分为公平锁和非公平锁。公平锁按照线程在队列中的排队顺序来获取锁，非公平锁则允许线程无视队列顺序直接去抢锁。
- 共享：多个线程可同时执行，如Semaphore、CountDownLatch、CyclicBarrier等。共享锁允许多个线程同时访问共享资源。
五、AQS的应用场景
AQS广泛应用于Java并发编程中，是实现各种同步机制的基础。
例如，ReentrantLock、Semaphore、CountDownLatch等同步器都是基于AQS实现的。
通过扩展AQS，开发者可以实现各种复杂的同步器，以满足不同的并发编程需求。
六、AQS的优缺点
优点：
- 提供了统一的同步器框架，简化了同步器的实现过程。
- 使用了FIFO队列来管理等待线程，保证了线程的公平性。
- 提供了灵活的资源共享方式，支持独占和共享两种模式。
缺点：
- AQS是一个相对复杂的框架，需要开发者对其内部机制有一定的了解才能正确使用。
- 在某些情况下，AQS的性能可能不如一些定制的同步器。
七、AQS示例
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.LockSupport;
// 自定义锁类
class MyLock implements Lock {
// 静态内部类，继承AQS
private static class Sync extends AbstractQueuedSynchronizer {
// 是否处于独占模式
protected boolean isHeldExclusively() {
return getState() == 1;
}
// 尝试获取锁，当状态为0时获取锁成功
public boolean tryAcquire(int acquires) {
assert acquires == 1; // 只允许获取1个单位的锁
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// 尝试释放锁，将状态设置为0
protected boolean tryRelease(int releases) {
assert releases == 1; // 只允许释放1个单位的锁
if (getState() == 0) throw new IllegalMonitorStateException();
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// 提供条件变量
Condition newCondition() { return new ConditionObject(); }
}
// 将操作代理到Sync上
private final Sync sync = new Sync();
// 实现Lock接口的方法
@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(unit.toNanos(time));
}
@Override
public void unlock() {
sync.release(1);
}
@Override
public Condition newCondition() {
return sync.newCondition();
}
public static void main(String[] args) {
MyLock lock = new MyLock();
Runnable task = () -> {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " 获取锁");
// 模拟任务执行
LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
} finally {
System.out.println(Thread.currentThread().getName() + " 释放锁");
lock.unlock();
}
};
Thread t1 = new Thread(task, "Thread-1");
Thread t2 = new Thread(task, "Thread-2");
t1.start();
t2.start();
}
}MyLock类：
- 实现
Lock接口，内部包含一个静态内部类Sync，该内部类继承自AbstractQueuedSynchronizer。
Sync类：
isHeldExclusively：判断当前线程是否持有锁。tryAcquire：尝试获取锁，如果当前状态为0（表示锁未被持有），则通过compareAndSetState方法将状态设置为1，并设置当前线程为独占线程。tryRelease：尝试释放锁，将状态设置为0，并清除独占线程。newCondition：创建一个条件变量。
MyLock方法：
- 将
Lock接口的方法代理到Sync对象上。
main方法：
- 创建两个线程，每个线程尝试获取和释放锁，模拟任务执行。
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。