ReentrantLock 能用于更精细化的加锁的Java类, 通过它能更清楚了解Java的锁机制
ReentrantLock 类的集成关系有点复杂, 既有内部类, 还有多重继承关系
### 类的定义
public class ReentrantLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = 7373984872572414699L;
/** Synchronizer providing all implementation mechanics */
private final Sync sync;
..............
- 实现了 Serializable 接口
- 实现了Lock接口, Lock 接口中就定义常用的加锁和释放锁的方法. 是一个基本的接口, 很多的锁类都实现了这个方法
- sync是它的重要成员变量, 加锁和解锁的操作都是通过这个变量实现的, 这个Sync 是一个静态内部类.
加锁的逻辑
ReentrantLock 的lock方法, tryLock方法和unlock方法
public void lock() {
sync.lock();
}
public void unlock() {
sync.release(1);
}
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
从上面的方法可以看出加锁的操作都是交给Sync类来实现的,下面就来看看Sync类
构造方法
/**
* Creates an instance of {@code ReentrantLock}.
* This is equivalent to using {@code ReentrantLock(false)}.
*/
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
两种构造方法其实是对应这两种锁, 公平锁和非公平锁, 公平锁是依赖FairSync 类来实现的, 非公平锁是依赖NonfairSync来实现的
NonfairSync类详解, 非公平获取锁的真正操作类
静态内部final类
/**
* Sync object for non-fair locks
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
NonfairSync类实现了虚拟类Sync 的lock 和tryAcquire 方法
而Sync 又继承了AbstractQueuedSynchronizer 虚拟类, AbstractQueuedSynchronizer 是一个很重要的类内部维护了 等待获取锁的线程队列
lock方法
加锁方法, 方法内有两个分支逻辑,
- 先判断是否是无锁状态并尝试加锁
compareAndSetState, 如果无锁且加锁成功则把当前线程加入AQS队列中setExclusiveOwnerThread. - 尝试获取锁没有成功, 就调用acquire 方法来获取锁
compareAndSetState方法判断
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
内部使用unsafe.compareAndSwapInt方法, 这方法是native方法. 是把比较和设置两步作为原子操作的方法.
setExclusiveOwnerThread方法
这个方法就是 AbstractQueuedSynchronizer 类的方法, 左右就是把当前线程标记成获取锁的线程
acquire方法, 真正获取锁的方法.
这个是NonfairSync 父类的父类AbstractQueuedSynchronizer 类的方法
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 如果获取到锁就会跳出这个循环, 如果获取不到锁, 会一直阻塞在这里
selfInterrupt();
}
内部一个if判断后的调用selfInterrupt方法. 重点在if判断中逻辑.
if中首先调用tryAcquire方法, tryAcquire 在AbstractQueuedSynchronizer 中 没有实现逻辑只是抛出异常, 所以具体的逻辑实在子类NonfairSync 中,
NonfairSync.tryAcquire方法
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
可以看到调用了nonfairTryAcquire 方法, nonfairTryAcquire方法又在Sync类中实现
Sync.nonfairTryAcquire方法如下
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread(); //获取当前线程
int c = getState(); // 获取当前锁的计数器
if (c == 0) { // 计数器0,说明当前锁是空闲的
if (compareAndSetState(0, acquires)) { //比较并获取锁
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) { // 当前线程就是已经获取锁的线程
int nextc = c + acquires; // 直接计数器上加 acquires, 传入的是1
if (nextc < 0) // 计数器数字异常
throw new Error("Maximum lock count exceeded");
setState(nextc); // 设置计数器的数值. 这里可以直接设置, 因为当前线程就是已经获取锁的线程, 可重入锁就是体现在这的
return true;
}
return false; // 获取锁失败
}
- 这个方法的作用, 就是看下锁的状态是否可以直接获取锁, 两种情况可以直接获取锁
- 锁是空闲状态, 没有线程获取锁
- 当前线程就是获取锁的线程, 直接计数器加值表示重复获取锁
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法,
这个也是AbstractQueuedSynchronizer 的方法. 这个方法才是真正的自旋阻塞获取锁的方法
/**
* Acquires in exclusive uninterruptible mode for thread already in
* queue. Used by condition wait methods as well as acquire.
*
* @param node the node
* @param arg the acquire argument
* @return {@code true} if interrupted while waiting
*/
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true; //自旋是否的标识符
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor(); //获取当前线程的上一个线程
if (p == head && tryAcquire(arg)) { // tryAcquire 就是尝试获取一下锁
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
- node.predecessor(); 就是获取当前线程的上一个线程
- 如果当前线程获取锁成功, 就把当前线程设置成队列的头部, 并且方法返回false
- 如果当前线程获取锁失败, 就进入shouldParkAfterFailedAcquire 方法, shouldParkAfterFailedAcquire内部会判断当前线程的上个线程的状态标记, 如果标记是<0(标识有问题) 就把上个线程移除队列, 如果标识是 SIGNAL就返回true, 如果是其他的就设置成SIGNAL 并且返回false. SIGNAL 标识线程阻塞中
- parkAndCheckInterrupt方法会判断当前线程是否应该中断,
- finally 中的方法 在正常获取到锁的时候回运行, cancelAcquire 中把当前线程和前面的线程都移除队列
- 其中addWaiter(Node.EXCLUSIVE) 方法就是把当前线程封装成Node, 并且把这个Node增加在队列的尾部
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;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) { // 把当前线程 比较并设置 成线程对列的尾部
pred.next = node;
return node;
}
}
// 设置失败就走到这里了
enq(node); //这个方法内部进行循环 比较并设置 成线程队列的尾部. 如果队列还是空的, 就new一个新的Node设置在头部
return node;
}
到这里 就是加锁逻辑全部走完
解锁的逻辑
unlock解锁方法
public void unlock() {
sync.release(1);
}
release方法在是在AQS中实现的
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 解锁方法
是在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); // 设置队列中锁线程标记为null
}
setState(c); // 设置新的计数器
return free;
}
- 释放锁的逻辑很简单
unparkSuccessor方法
在释放锁成功后, 会进行这个方法. 这个方法会把后续的线程唤醒. LockSupport.unpark(s.thread); 就是唤醒线程方法
private void unparkSuccessor(Node node) {
// 将状态设置为同步状态
int ws = node.waitStatus;
if (ws < 0) compareAndSetWaitStatus(node, ws, 0); // 获取当前节点的后继节点，如果满足状态，那么进行唤醒操作 // 如果没有满足状态，从尾部开始找寻符合要求的节点并将其唤醒 Node s = node.next; if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
FairSync公平锁的逻辑
lock方法
加锁逻辑, 与NoFairSync区别是直接
final void lock() {
acquire(1);
}
acquire方法与非公平锁的方法一样
tryAcquire方法
这个方法与NonfairSync中tryAcquire方法有区别的, NonfairSync中的tryAcquire 是调用了父类Sync中的nonfairTryAcquire方法, 感觉这里有点奇怪
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;
}
- hasQueuedPredecessors方法中的逻辑很绕, hasQueuedPredecessors 判断当前线程在队列中的第二位, 是返回false, 否则返回true
- 是第二位, 则进行compareAndSetState 方法, 比较并设置, 如果锁没有线程获取就尝试获取. 获取成功就标记当前线程为获取锁线程
- 如果state 不是0 , 表示已经有线程获取锁了,
if (current == getExclusiveOwnerThread())判断当前线程是否已经是获取锁的线程. - 如果最终还是没有获取锁成功, 就返回false
公平锁和非分公平锁的获取锁的区别
Lock方法中的区别
- 公平锁中lock 会直接进入acquire 方法, 会直接进入队列中获取锁
- 非公平锁, 会先尝试下判断当前线程是否已经获取锁, 获取锁计数器0 尝试获取下, 获取失败才会进入acquire 方法
tryAcquire方法中的区别, 这个方法才是真正的一次获取锁的方法,
- 公平锁在compareAndSetState之前会调用下hasQueuedPredecessors 方法, 判断下当前节点是否是第二节点. 是第二节点才会获取锁
- 非公平锁 没有hasQueuedPredecessors判断.