注意:本文基于JDK1.8进行记录。
1 简介
1.1 是什么
AQS是英文单词AbstractQueuedSynchronizer的缩写,翻译过来就是抽象的队列式的同步器,AQS定义了一套多线程访问共享资源的同步器框架,许多同步类实现都依赖于它,如常用的ReentrantLock、Semaphore、CountDownLatch等等。
AQS是用来构建锁或者其它同步器组件的重量级基础框架及整个JUC体系的基石,通过内置的FIFO队列来完成资源获取线程的排队工作,并通过一个state整型变量表示持有锁的状态。
1.2 抽象
AQS的主要使用方式是继承,子类通过继承同步器并实现它的抽象方法来管理同步状态。
1.3 原理
抢到资源的线程直接使用处理业务逻辑,抢不到资源的必然涉及一种排队等候机制。既然说到了排队等候机制,那么就一定会有某种队列形成,这样的队列是什么数据结构呢。
如果共享资源被占用,就需要一定的阻塞等待唤醒机制来保证锁分配。这个机制主要用的是CLH队列的变体实现的,将暂时获取不到锁的线程加入到队列中,这个队列就是AQS的抽象表现。它将请求共享资源的线程封装成队列的Node结点,通过CAS、自旋以及LockSupport的凭证机制,维护state变量的状态,使并发达到同步的控制效果。
CLH:Craig、Landin、Hagersten(三个科学家名字)队列,原版是一个单向链表,AQS中的队列是CLH变体的虚拟双向队列FIFO,其头节点在初始化后变为空节点。
1.4 资源使用方式
AQS定义两种资源使用方式:Exclusive(独占,只有一个线程能执行,如ReentrantLock)和Share(共享,多个线程可同时执行,如Semaphore/CountDownLatch)。
2 体系架构
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
...
// 内部封装Node节点
static final class Node {
// 标记线程以共享的模式等待锁
static final Node SHARED = new Node();
// 标记线程以独占的模式等待锁
static final Node EXCLUSIVE = null;
// waitStatus取值为1表示线程取消(超时、中断),被取消的节点不会阻塞
static final int CANCELLED = 1;
// waitStatus取值为-1表示后继节点已经准备完成,等待线程释放资源
static final int SIGNAL = -1;
// waitStatus取值为-2表示线程在Condition队列中阻塞,当其他线程调用了Condition中的唤醒方法后,将节点从Condition队列转移到CLH等待队列(Condition中有使用)
static final int CONDITION = -2;
// waitStatus取值为-3表示线程及后续线程无条件传播(共享模式可用,CountDownLatch中有使用)
static final int PROPAGATE = -3;
// 线程的等待状态,初始值为0
volatile int waitStatus;
// 前驱节点
volatile Node prev
// 后继节点
volatile Node next;
// 线程对象
volatile Thread thread;
...
}
// 头节点
private transient volatile Node head
// 尾节点
private transient volatile Node tail;
// 资源状态,0表示可获取,大于等于1表示已占用
private volatile int state;
// 获取资源状态
protected final int getState() {
return state;
}
// 设置资源状态
protected final void setState(int newState) {
state = newState;
}
// CAS设置资源状态
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
...
}
AQS使用了一个volatile修饰的整型变量state用来表示同步状态,通过内置的CLH同步队列来完成线程的排队工作。
其中,对state值的修改是通过CAS完成的,0表示资源可用,大于等于1表示资源不可用。AQS提供了三种操作state的方法:getState()、setState()、compareAndSetState()。
当前线程根据state的值判断能否获取资源,如果获取失败,AQS会将当前线程thread以及等待状态waitStatus等信息封装成Node节点,并将其加CLH入同步队列,同时阻塞当前线程。当state的值变为可获取资源后,会把Node节点中的线程唤醒,再次尝试获取资源。
3 Lock与AQS
Lock接口的实现类,基本都是通过聚合了一个队列同步器的子类完成线程访问控制的。
public class ReentrantLock implements Lock, java.io.Serializable {
...
abstract static class Sync extends AbstractQueuedSynchronizer {
...
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
...
}
static final class NonfairSync extends Sync {
...
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
static final class FairSync extends Sync {
...
final void lock() {
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
...
}
ReentrantLock类的内部聚合了一个Sync类,Sync类继承了AQS类,并且非公平锁NonfairSync和公平锁FairSync都继承自Sync,默认创建的是非公平锁NonfairSync。
4 分析ReentrantLock
4.1 概述
整个ReentrantLock的加锁过程,可以分为三个阶段:
1)尝试加锁。
2)加锁失败,线程入队列。
3)线程入队列后,进入阻赛状态。
4.2 场景举例
举例三个客户在银行办理业务,使用默认的非公平锁:
public static void main(String[] args) {
Lock lock = new ReentrantLock();
new Thread(()->{
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "-----办理业务");
try {
TimeUnit.SECONDS.sleep(60);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-----离开");
} finally {
lock.unlock();
}
}, "A").start();
new Thread(()->{
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "-----办理业务");
try {
TimeUnit.SECONDS.sleep(60);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-----离开");
} finally {
lock.unlock();
}
}, "B").start();
new Thread(()->{
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "-----办理业务");
try {
TimeUnit.SECONDS.sleep(60);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-----离开");
} finally {
lock.unlock();
}
}, "C").start();
}
5 程序分析
5.1 线程A开始并执行
5.1.1 获取资源
线程A进入,调用lock()方法,查看实现:
final void lock() {
// 使用CAS设置state为1
if (compareAndSetState(0, 1))
// 表示获取资源成功,将当前线程设为占用线程
setExclusiveOwnerThread(Thread.currentThread());
else
// 表示获取资源失败,继续抢占资源
acquire(1);
}
因为线程A是第一个获取资源的线程,所以使用compareAndSetState()方法设置成功,继续调用setExclusiveOwnerThread()方法将当前线程设为占用线程,然后继续执行业务。
5.2 线程B开始并阻塞
5.2.1 获取资源
线程B进入,调用lock()方法。
因为线程B是第二个获取资源的线程,线程A已经将state从0改为了1,所以使用compareAndSetState()方法设置失败。
5.2.2 抢占资源
线程B进入,继续调用acquire()方法抢占资源,查看实现:
public final void acquire(int arg) {
// 抢占资源
if (!tryAcquire(arg) &&
// 加入等待队列
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
// 线程阻塞
selfInterrupt();
}
继续调用tryAcquire()方法抢占资源,查看实现:
protected final boolean tryAcquire(int acquires) {
// 继续调用非公平锁的尝试抢占方法
return nonfairTryAcquire(acquires);
}
继续调用非公平锁的nonfairTryAcquire()方法,返回false表示占用失败:
final boolean nonfairTryAcquire(int acquires) {
// 记录当前线程
final Thread current = Thread.currentThread();
// 记录当前资源状态
int c = getState();
// 0表示当前资源可用
if (c == 0) {
// 使用CAS设置state为请求数
if (compareAndSetState(0, acquires)) {
// 表示获取资源成功,将当前线程设为占用线程
setExclusiveOwnerThread(current);
return true;
}
}
// 大于等于1表示当前资源被占用,判断当前线程是否为占用线程(可重入锁的情况)
else if (current == getExclusiveOwnerThread()) {
// 当前线程为占用线程,记录资源状态
int nextc = c + acquires
// 判断是否溢出
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 设置state为新的资源状态
setState(nextc);
return true;
}
return false;
}
因为线程B是第二个获取资源的线程,线程A已经将state从0改为了1,返回false,将当前线程加入等待队列并阻塞。
5.2.3 进入等待
线程B进入,继续调用addWaiter()方法将当前线程加入等待队列,查看实现:
private Node addWaiter(Node mode) {
// 将当前线程和传入的独占模式封装为节点
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
// 尾节点不为空,表示CLH队列已经初始化,CAS操作将当前节点设为尾节点
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 尾节点为空,表示CLH队列还未初始化,初始化队列
enq(node);
return node;
}
因为线程B是第一个进入等待的线程,尾节点为空,继续查看enq()方法:
private Node enq(final Node node) {
for (;;) {
Node t = tail;
// 尾节点为空,通过CAS设置头节点和尾节点为空节点
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 尾节点不为空,通过CAS将当前节点作为新的尾节点
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
初始化CLH队列后,头节点为空节点,尾节点为当前节点。
5.2.4 阻塞线程
线程B得到当前节点后,作为参数传入acquireQueued()方法继续执行:
final boolean acquireQueued(final Node node, int arg) {
// 记录当前节点是否取消,默认为true,表示取消
boolean failed = true;
try {
// 标记当前节点是否中断,默认为false,表示当前节点没有中断
boolean interrupted = false
// 自旋
for (;;) {
// 获取当前节点的上一节点
final Node p = node.predecessor();
// 如果当前节点是头节点,表示当前节点即将被唤醒,尝试抢占资源
if (p == head && tryAcquire(arg)) {
// 将当前节点设为头节点,置空当前节点的上一节点,并取消当前节点同当前线程的绑定
setHead(node);
// 将原头节点的下一节点置空,方便GC回收
p.next = null; // help GC
// 标记当前节点为false,表示没有取消
failed = false;
// 返回false,表示当前节点没有中断
return interrupted;
}
// 不管当前节点是不是头节点,执行到这里就表示获取资源失败,处理前置节点并阻塞当前节点
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 标记为true,表示当前节点中断
interrupted = true;
}
} finally {
// 当前节点如果被取消,执行取消操作
if (failed)
cancelAcquire(node);
}
}
因为线程B是第一个进入等待的线程,上一节点为头节点,尝试获取资源。获取成功则将当前节点作为头节点并移除当前线程,获取失败则进入判断。
在判断条件中调用shouldParkAfterFailedAcquire()方法,处理前置节点:
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// 记录上一节点的等待状态
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
// 如果上一节点的等待状态为-1,表示当前线程可以被阻塞,返回true,执行parkAndCheckInterrupt()方法
return true;
if (ws > 0) {
// 如果上一节点的等待状态为1,表示上一节点被取消,循环移除被取消的上一节点
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 上述条件不满足,表示上一节点的等待状态为0或者-3,通过CAS将等待状态设置为-1
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
// 返回false,跳过parkAndCheckInterrupt()方法,重新进入自旋
return false;
}
因为线程B是第一个进入等待的线程,上一节点为头节点,头节点为空节点,等待状态为0,所以两次进入此方法。
第一次进入shouldParkAfterFailedAcquire()方法将上一节点的等待状态设置为-1后返回false,条件判断为false重新进入自旋。
第二次进入shouldParkAfterFailedAcquire()方法检测到上一节点的等待状态为-1,返回true,继续判断parkAndCheckInterrupt()方法。
在判断条件中调用parkAndCheckInterrupt()方法,阻塞当前节点:
private final boolean parkAndCheckInterrupt() {
// 使用LockSupport的park()方法阻塞当前节点
LockSupport.park(this);
// 返回线程的中断状态
return Thread.interrupted();
}
线程B在此被阻塞。
5.3 线程C开始并阻塞
5.3.1 获取资源
线程C进入,调用lock()方法。
因为线程C是第三个获取资源的线程,线程A已经将state从0改为了1,所以使用compareAndSetState()方法设置失败。
5.3.2 抢占资源
线程C进入,继续调用acquire()方法抢占资源。
继续调用tryAcquire()方法抢占资源。
继续调用非公平锁的nonfairTryAcquire()方法,返回false表示占用失败。
因为线程C是第三个获取资源的线程,线程A已经将state从0改为了1,返回false,将当前线程加入等待队列并阻塞。
5.3.3 进入等待
线程C进入,继续调用addWaiter()方法将当前线程加入等待队列。
因为线程C是第二个进入等待的线程,线程B已经完成了队列初始化,尾节点不为空,将当前节点作为新的尾节点。
5.3.4 阻塞线程
线程C得到当前节点后,作为参数传入acquireQueued()方法继续执行。
因为线程C是第二个进入等待的线程,上一节点不为头节点,直接进入判断。
在判断条件中调用shouldParkAfterFailedAcquire()方法,处理前置节点,将B节点的等待状态设为-1,返回true,继续判断parkAndCheckInterrupt()方法。
在判断条件中调用parkAndCheckInterrupt()方法,阻塞当前节点。
线程C在此被阻塞。
5.4 线程A结束
5.4.1 解锁资源
线程A执行完毕,调用unlock()方法释放资源并唤醒线程,查看实现:
public void unlock() {
sync.release(1);
}
继续查看release()方法:
public final boolean release(int arg) {
// 调用tryRelease()方法尝试释放资源
if (tryRelease(arg)) {
// 获取头节点
Node h = head;
// 如果头节点不为空,并且等待状态不为0,表示需要唤醒其他线程
if (h != null && h.waitStatus != 0)
// 调用unparkSuccessor()方法并传入头节点,唤醒线程
unparkSuccessor(h);
return true;
}
// 释放失败返回false
return false;
}
5.4.2 释放资源
继续查看tryRelease()方法:
protected final boolean tryRelease(int releases) {
// 记录资源状态
int c = getState() - releases;
// 如果当前线程不为占用线程则抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
// 标记资源空闲,默认为false
boolean free = false
// 资源状态为0则标记资源空闲为true,并将占用线程置空
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
// 设置资源状态
setState(c);
// 返回资源空闲
return free;
}
线程A释放资源并返回true,继续执行。
5.4.3 唤醒线程
因为线程B和线程C已经进入等待队列,所以头节点不为空,继续查看unparkSuccessor()方法:
private void unparkSuccessor(Node node) {
// 记录头节点的等待状态
int ws = node.waitStatus;
// 如果头节点的等待状态小于0,则将头节点的等待状态设为0
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 记录头节点的下一节点
Node s = node.next;
// 判断下一节点是否为空或者下一节点的等待状态是否大于0
if (s == null || s.waitStatus > 0) {
s = null;
// 遍历下一节点,找到不为空并且等待状态小于等于0的节点,将其设为下一节点
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 如果下一节点不为空,则使用LockSupport的unpark()方法唤醒下一节点中的线程
if (s != null)
LockSupport.unpark(s.thread);
}
头节点的下一节点为线程B所在的节点,线程B被唤醒。
5.5 线程B执行并结束
5.5.1 抢占资源
线程B在parkAndCheckInterrupt()方法中被释放后,返回中断状态为false,重新进入自旋:
final boolean acquireQueued(final Node node, int arg) {
// 记录当前节点是否取消,默认为true,表示取消
boolean failed = true;
try {
// 标记当前节点是否中断,默认为false,表示当前节点没有中断
boolean interrupted = false
// 自旋
for (;;) {
// 获取当前节点的上一节点
final Node p = node.predecessor();
// 如果当前节点是头节点,表示当前节点即将被唤醒,尝试抢占资源
if (p == head && tryAcquire(arg)) {
// 将当前节点设为头节点,置空当前节点的上一节点,并取消当前节点同当前线程的绑定
setHead(node);
// 将原头节点的下一节点置空,方便GC回收
p.next = null; // help GC
// 标记当前节点为false,表示没有取消
failed = false;
// 返回false,表示当前节点没有中断
return interrupted;
}
// 不管当前节点是不是头节点,执行到这里就表示获取资源失败,处理前置节点并阻塞当前节点
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 标记为true,表示当前节点中断
interrupted = true;
}
} finally {
// 当前节点如果被取消,执行取消操作
if (failed)
cancelAcquire(node);
}
}
因为线程B的上一节点为头节点,进入tryAcquire()方法抢占资源,抢占成功返回true并将当前节点设为头节点,同时解除同线程B的绑定。
5.5.2 解锁资源
线程B执行完毕,调用unlock()方法释放资源并唤醒线程。
头节点的下一节点为线程C所在的节点,线程C被唤醒。
5.6 线程C执行并结束
5.6.1 抢占资源
线程C在parkAndCheckInterrupt()方法中被释放后,返回中断状态为false,重新进入自旋。
因为线程C的上一节点为头节点,进入tryAcquire()方法抢占资源,抢占成功返回true并将当前节点设为头节点,同时解除同线程C的绑定。
5.6.2 解锁资源
线程C执行完毕,调用unlock()方法释放资源并唤醒线程。
头节点的下一节点为空,不会有任何线程被唤醒。
6 公平锁与非公平锁
6.1 非公平锁
非公平锁的线程在获取资源时,会尝试获取资源,如果成功则立刻占用资源,如果失败则尝试占用资源。
在资源可用时不会判断当前队列是否有线程在等待,也就是说刚加入的线程可以同唤醒的线程竞争资源。
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
...
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
...
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
...
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
6.2 公平锁
公平锁的线程在获取资源时,不会尝试获取资源,而是尝试占用资源。
在资源可用时会判断当前队列是否有线程在等待,刚加入的线程不可用同唤醒的线程竞争资源。
final void lock() {
acquire(1);
}
...
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
...
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
6.3 分析hasQueuedPredecessors()方法
比较NonfairSync和FairSync中tryAcquire()方法的实现,发现FairSync中的tryAcquire()方法中多了一项判断:
!hasQueuedPredecessors()
hasQueuedPredecessors()方法用于公平锁加锁时判断等待队列中是否存在有效节点的方法。该方法用于判断当前节点前是否有其他节点排队:
返回false表示没有,取反后为true表示当前节点不需要排队,需要继续执行占用资源的操作。
返回true表示有,取反后为false表示当前节点需要排队,需要执行加入等待队列的操作。
查看AQS中定义的hasQueuedPredecessors()方法:
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
判断h是否不等于t,如果不成立,说明h等于t,说明头节点和尾节点相同,说明当前队列未初始化(头节点和尾节点都是空节点)或者当前队列只有一个节点(头结点和尾节点都是空节点),说明不需要排队,返回false,取反后为true,尝试占用资源。
判断h是否不等于t,如果成立,说明h不等于t,说明存在两个不同节点。继续判断头节点的下一节点是否为空节点,如果成立,说明下一节点为空,可能上个线程在执行初始化enq()方法,刚刚通过CAS操作compareAndSetHead()将头节点初始化,尚未给尾节点赋值,此时头节点不为空,尾节点为空,并且头节点的下一节点为空,返回true,取反后为false,需要排队。
判断h是否不等于t,如果成立,说明h不等于t,说明存在两个不同节点。继续判断头节点的下一节点是否为空节点,如果不成立,说明下一节点不为空。继续判断下一节点封装的线程是否不等于当前线程,如果成立,说明下一线程不为当前线程,返回true,取反后为false,需要排队。
判断h是否不等于t,如果成立,说明h不等于t,说明存在两个不同节点。继续判断头节点的下一节点是否为空节点,如果不成立,说明下一节点不为空。继续判断下一节点封装的线程是否不等于当前线程,如果不成立,说明下一线程为当前线程,返回false,取反后为true,尝试占用资源。
7 自定义同步器
7.1 实现方法
不同的自定义同步器争用共享资源的方式也不同,自定义同步器在实现时只需要实现共享资源state的获取与释放即可,至于具体线程等待队列的维护(如获取资源失败入队和唤醒出队等),AQS已经在底层实现好了。
自定义同步器实现时主要实现以下几种方法:
isHeldExclusively():该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int):独占方式。尝试获取资源,成功则返回true,失败则返回false。
tryRelease(int):独占方式。尝试释放资源,成功则返回true,失败则返回false。
tryAcquireShared(int):共享方式。尝试获取资源。负数表示失败;0表示成功,但没有剩余可用资源;正数表示成功,且有剩余资源。
tryReleaseShared(int):共享方式。尝试释放资源,如果释放后允许唤醒后续等待结点返回true,否则返回false。
一般来说,自定义同步器要么是独占方法,要么是共享方式,他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式,如ReentrantReadWriteLock。
7.2 举例说明
7.2.1 ReentrantLock
以ReentrantLock为例,state初始化为0,表示未锁定状态。
当线程A调用lock()方法获取资源时,会调用tryAcquire()占用资源,并将state的值加1。
此后,其他线程再tryAcquire()时就会失败,直到线程A调用unlock()方法释放资源,并将state的值减0,其它线程才有机会获取该锁。
当然,释放锁之前,A线程自己是可以重复获取此锁的(state会累加),这就是可重入的概念。但要注意,获取多少次就要释放多少次,这样才能保证state是能回到零态的。
7.2.2 CountDownLatch
再以CountDownLatch以例,任务分为N个子线程去执行,state也初始化为N(N与线程个数一致)。这N个子线程是并行执行的,每个子线程执行完后都会调用一次countDown()方法,使用CAS操作将state值减1。等到所有子线程都执行完后,state的值变为0,这时会调用unpark()方法唤醒主线程,然后主线程就会从await()方法唤醒,继续后余动作。