AQS 初步认识
AQS 核心源码
获取锁
public final void acquire(int arg) {
// 尝试获取锁失败后，将当前线程加入阻塞队列
if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
protected boolean tryAcquire(int arg) {
// 尝试获取锁的具体逻辑由子类实现
throw new UnsupportedOperationException();
}
释放锁
public final boolean release(int arg) {
if (tryRelease(arg)) {
// 尝试释放锁
Node h = head;
if (h != null && h.waitStatus != 0)
// 释放后唤醒队列的头结点
unparkSuccessor(h);
return true;
}
return false;
}
ReentrantLock
成员变量和构造函数
public class ReentrantLock implements Lock {
// 抽象同步器
private final Sync sync;
abstract static class Sync extends AbstractQueuedSynchronizer {}
// 非公平锁实现
static final class NonfairSync extends Sync {}
// 公平锁实现
static final class FairSync extends Sync {}
// 默认是非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
// 可以指定公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
}
公平锁和非公平锁
传统的误区认为公平锁是先来后到的，非公平锁是竞争抢的。其实公平锁还是非公平锁也好都是先来后到的。
公平与非公平的决定性差异在于，当线程释放时同时有队列的线程和新的线程的时候，新线程能否竞争抢锁。对于非公平锁，新线程可以参与竞争抢锁。对于公平锁，新的线程要上锁时发现队列中有线程，则不得抢锁。
所以公平与非公平锁的差异是很细微的，一般很难判断区分公平与非公平的实际运行差异。但是在高并发场景下，使用非公平锁是能够稳妥保证不会发生线程饥饿问题。
推测历史，大概一开始只实现了非公平锁，后来发现存在饥饿问题便提供扩展了公平锁实现~
非公平锁 NonfairSync
final void lock() {
// 先尝试自己主动CAS获取锁 如果获取成功设置当前线程独占(步骤前置优化)
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
// 自己尝试的CAS失败，进入整个AQS上锁逻辑
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
// TODO 备注：这个方法实际上是写到了公共同步器Sync上的，这里为了代码结构和文章结构统一放一起讲
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) { // 没有线程占用锁,可以上锁
// CAS 让当前线程抢锁
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;
}
公平锁 FairSync
final void lock() {
// mark: 非公平锁还优化 公平锁懒得优化了
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) { // 没有线程占用锁,可以上锁
// 队列中是否有其他线程 如果没有才允许进行CAS抢锁 (如果有会返回false，进入AQS阻塞逻辑)
if (!hasQueuedPredecessors() && 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;
}
ReentrantLock 的公共同步器 Sync
释放锁逻辑是公共的
protected final boolean tryRelease(int releases) {
int c = getState() - releases; // 拿到释放锁后的重入次数
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException(); // 如果当前线程不是持有该对象锁的线程，说明是非法释放锁，抛异常
boolean free = false;
if (c == 0) {
// 重入次数为0，释放锁成功，并设置当前持有对象锁的线程为空，注意到这一步还没有完成释放锁逻辑
free = true;
setExclusiveOwnerThread(null);
}
// CAS设置state状态，这一步才算真正完成释放锁逻辑，允许其他线程来抢锁
setState(c);
return free;
}
ReentrantReadWriteLock
成员变量和构造函数
public class ReentrantReadWriteLock implements ReadWriteLock {
private final ReentrantReadWriteLock.ReadLock readerLock; // 读锁
private final ReentrantReadWriteLock.WriteLock writerLock; // 写锁
final Sync sync; // 公共同步器
// 默认非公平实现
public ReentrantReadWriteLock() {
this(false);
}
// 可以指定公平锁
public ReentrantReadWriteLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
}
public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
public ReentrantReadWriteLock.ReadLock readLock() { return readerLock; }
abstract static class Sync extends AbstractQueuedSynchronizer {}
static final class NonfairSync extends Sync {}
static final class FairSync extends Sync {}
public static class ReadLock implements Lock {}
public static class WriteLock implements Lock {}
}
读写锁的公平与非公平性
ReadLock 读锁
public static class ReadLock implements Lock {
private final Sync sync;
protected ReadLock(ReentrantReadWriteLock lock) {
sync = lock.sync;
}
public void lock() {
sync.acquireShared(1); // AQS 提供的共享锁的方法
}
public boolean tryLock() {
return sync.tryReadLock();
}
public void unlock() {
sync.releaseShared(1);
}
}
可以看到本身是全都委派到AQS方法上了，但这里为了文章结构，先把这些方法统一放这里看
