回眸重探锁机制，3面直接拿到offer

• nextWaiter:有两种职责；如果为空时标识独占节点，为SHARED时表示共享节点，其它值时表示条件等待节点数据结构(后面介绍条件锁时，会把这个结构单独列出)

6.2 独占锁

6.2.1 获取资源

可以通过下面几种方法来获取

• void acquire(int arg)：获取锁，arg一般来说是1

public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}

• void acquireInterruptibly(int arg)：获取锁，抛出打断异常

public final void acquireInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}

• boolean tryAcquireNanos(int arg, long nanosTimeout)：获取锁存在最长时间，抛出打断异常

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
return tryAcquire(arg) ||
doAcquireNanos(arg, nanosTimeout);
}

可见，如果tryAcquire返回true时，相应方法也就结束了，线程后续方法即可继续执行，也就是获取锁了；而如果返回false时，后面方法则很大可能会触发线程暂停

protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}

tryAcquire方法需要用户自实现；现有锁都是通过AQS中state整数变量来实现的

6.2.2 释放资源

public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}

这里tryRelease返回true时，才有可能通知其它线程去竞争资源；

protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}

需要用户自实现；现有锁都是通过AQS中state整数变量来实现的

6.3 独占锁

6.3.1 获取资源

同样存在不同的入口

• void acquireShared(int arg):获取共享锁

public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}

• void acquireSharedInterruptibly(int arg):获取共享锁，会抛出打断异常

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}

• boolean tryAcquireSharedNanos(int arg, long nanosTimeout)：获取锁有时间限制，超过则结束返回是否获取成功；会抛出打断异常

public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
return tryAcquireShared(arg) >= 0 || doAcquireSharedNanos(arg, nanosTimeout);
}

这里获取资源的条件是受 tryAcquireShared的返回值来控制的，>=0时，线程继续执行，否则，很可能会线程暂停； tryAcquireShared方法需要用户实现，也会通过AQS中state变量来处理

protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}

6.3.2 释放资源

释放时也只有一个入口

public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}

tryReleaseShared返回true时，才有可能去唤醒其它线程去竞争资源；也需要用户实现，同样，也是基于AQS中state变量来控制

protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}

6.4 可重入

可重入性，是持有资源者，再次自动持有资源的行为；这些在独占锁锁中，只需要线程判断即可，而共享锁，则是不仅仅需要线程判断，还需要一些列共享持有者单独比对，无疑当前线程比对可以优化这个过程；线程的存储AQS已经提供方法，这些方法来源于其继承的抽象类AbstractOwnableSynchronizer，而是否持有，则由方法isHeldExclusively提供，而这个方法需要用户实现

protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}

6.5 数据变化

数据变化，涉及到几个重要方法：

• addWaiter：从双端队列，队尾加入节点；线程获取资源失败时，会生成节点并加入队列；而条件锁在等待唤醒时被唤醒后，通过enq方法加入队列
• shouldParkAfterFailedAcquire:决定是否暂停当前线程，在循环中处理
• parkAndCheckInterrupt：暂停线程，并返回打断状态且重置打断状态
• unparkSuccessor：唤醒等待资源的线程，进行资源竞争获取

6.5.1 添加节点

独占资源

共享资源

条件资源

6.5.2 线程执行异常或者被打断

独占资源

共享资源

6.5.3 等待状态

相对于5.5.2，其中变化的仅仅waitStatus = -1

6.5.4 条件唤醒状态

这是条件锁特有状态；实现原理是：首先节点在条件单列表条件链表中等待；两个等待循环条件为是否在资源竞争的双向列表中(就是独占/共享的队列)，如果被唤醒，其就会在此队列了，然后调用独占锁的逻辑获取锁 其关键方法：

• isOnSyncQueue：是否存在AQS中的双向队列中，被唤醒后存在
• doSignal：移除条件单向列表列中头节点，并改变状态waitStatus=0，加入AQS双向列表中去

6.6 条件锁使用条件

final int fullyRelease(Node node) {
try {
int savedState = getState();
if (release(savedState))
return savedState;
throw new IllegalMonitorStateException();
} catch (Throwable t) {
node.waitStatus = Node.CANCELLED;
throw t;
}
}

这个方法是在获取资源时均会调用的方法；会首先释放state个资源使用权，然后通过加入队列后通过相应方法获取state个使用权；释放不了state个使用权会直接报异常；因此，条件锁使用时，必须在当前已经获取资源使用权的情况使用下，且仅仅只有其自己获取资源使用权；

6.7 小结

其在性能上有许多要学习的地方：比如在获取资源执行权时，并没有立刻去暂停线程；在状态变化过程中，也没有仅仅考虑当前状态，也进行有可能的唤醒线程竞争、去除无效资源等；整体采用自旋+CAS机制处理；

7 android中的锁

7.1 synchronized关键字

上面介绍锁概念时大致介绍了这个关键字，其通过编译时在代码块加入同步指令处理的；是以特殊的一个对象作为锁的标志：

• 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
• 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
• 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

通过锁对象来实现条件策略；这写方法来源于Object的wait/notify/notifyAll方法

7.2 ReentrantLock锁

可重入锁、独占锁；有两种模式：公平、非公平，可通过构造器进行设定；公平不公平，就是在获取资源执行权时，是否按照排队顺序优先获取来定的

公平锁

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;
}

这里有两种获取锁的方式：

1. 当前state=0，AQS队列中无排队线程，且CAS操作state成功，则把记录当前线程
2. 当前线程为上次纪律线程，则把state再次增加

为什么公平，就是因为，可获取资源时，先检查当前排队队列是否为空，为空才会获取

非公平锁

final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}

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;
}

获取锁资源成功条件

1. 对state进行CAS操作，成功；记录线程
2. 如果当前资源可被获取也即state = 0时，对state进行CAS操作成功；记录线程
3. 当前线程为记录线程

唤醒竞争

protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState©;
return free;
}

state为0时，才会唤醒其它线程进行竞争；而不为0时，只是进行减少，这于可重入处理时相加相对应；所以加锁和解锁要成对出现

7.3 ReentrantReadWriteLock锁

可重入锁；独占锁和共享锁共存； 读写锁；其读锁调用AQS的共享资源方法，写锁调用AQS独占资源方法；其也存在两种模式：公平、非公平，可通过构造器进行设定；

公平/非公平模式

1. 对于写锁，公平时查看当前是否排队的，排队优先，非公平时，尝试获取资源的线程优先
2. 对于读锁，公平模式时同样查看当前是否有排队的，排队优先，非公平时，根据排队等待的对头是否为独占节点

也即是依靠如下方法：返回true表示公平模式

abstract boolean readerShouldBlock();
abstract boolean writerShouldBlock()

条件锁

1. 读锁：直接抛出UnsupportedOperationException异常
2. 写锁：使用AQS实现类调用newCondition生成

state状态

读锁，通过state的低16位来确定个数；写锁通过state的高16位来确定

独占资源处理

protected final boolean tryRelease(int releases) {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int nextc = getState() - releases;
boolean free = exclusiveCount(nextc) == 0;
if (free)
setExclusiveOwnerThread(null);
setState(nextc);
return free;
}

唤醒处理和ReentrantLock没有区别

protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
int c = getState();
int w = exclusiveCount©;
if (c != 0) {
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error(“Maximum lock count exceeded”);
setState(c + acquires);
return true;
}
if (writerShouldBlock() ||
!compareAndSetState(c, c + acquires))
return false;
setExclusiveOwnerThread(curren
t);
return true;
}

获取资源时，逻辑如下：

1. state!=0,而排队的独占节点为0，或者不为记录线程；则获取失败，这时优先读锁
2. state!=0,而排队中存在独占节点且为当前线程已经获得执行权，则获取成功
3. 写公平模式或者CAS操作state失败，获取失败，否则成功

共享资源处理

这个相对于独占就复杂多了

protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
if (firstReader == current) {
if (firstReaderHoldCount == 1)
firstReader = null;
else
firstReaderHoldCount–;
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
rh = readHolds.get();
int count = rh.count;
if (count <= 1) {
readHolds.remove();
if (count <= 0)
throw unmatchedUnlockException();
}
–rh.count;
}
for (;😉 {
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}

对是否需要唤醒时，首先需要处理共享的数据，然后才是state的CAS操作且是循环操作

• 共享数据： firstReader共享节点的第一个线程对象，firstReader线程对象对应的重入数目firstReaderHoldCount；cachedHoldCounter：最后一个共享节点对象线程tid和持有重入数目；readHolds为HoldCounte线程存储
• CAS循环操作的原因：因为读操作可能同时存在多个，保证state的安全

protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
int c = getState();
if (exclusiveCount© != 0 &&
(compareAndSetState(c, nextc))
return nextc == 0;
}
}

对是否需要唤醒时，首先需要处理共享的数据，然后才是state的CAS操作且是循环操作

• 共享数据： firstReader共享节点的第一个线程对象，firstReader线程对象对应的重入数目firstReaderHoldCount；cachedHoldCounter：最后一个共享节点对象线程tid和持有重入数目；readHolds为HoldCounte线程存储
• CAS循环操作的原因：因为读操作可能同时存在多个，保证state的安全

protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
int c = getState();
if (exclusiveCount© != 0 &&