Análise aprofundada do princípio do ReentrantLock - com base no jdk1.8
O ReentrantLock explica principalmente os métodos de bloqueio e desbloqueio. Vamos ver como ele percebeu a reentrada de trancar e esperar a liberação da trava.
1. Primeiro, observe o método de inicialização
/**
* 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(); // 公平锁
}
Existem duas classes internas mencionadas aqui:
1. new FairSync ();
2. new NonfairSync ();
sua principal diferença é o método de bloqueio
1. O NonfairSync tentará primeiro adquirir o bloqueio e, em seguida, será adicionado à fila e entrará no estado de espera após a falha da aquisição
2. FairSync primeiro determine se o bloqueio é ocupada por outros tópicos, em caso afirmativo entra na cauda da espera fila para
a possuir a classe ReentrantLock.Sync, classe ReentrantLock.Sync também herdou a AbstractQueuedSynchronizer
1. ReentrantLock.Sync alguns métodos públicos de classe
2. AbstractQueuedSynchronizer interna mantém um Uma fila implementada por uma lista duplamente vinculada é usada para registrar threads aguardando liberação do bloqueio,
Na operação real, o NonfairSync é usado mais.Aqui está um estudo do
NonfairSync for NonfairSync:
/**
* 非公平锁的同步对象
* 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);
}
}- Primeiro, observe o método de bloqueio
final void lock() {
// 通过原子操作 改变上锁状态
if (compareAndSetState(0, 1)) // 变更成功
setExclusiveOwnerThread(Thread.currentThread()); // 设置持有者为当前线程
else // 变更成功
acquire(1);
}Abaixo o cartão na ordem de código
1.1 compareAndSetState
private static final Unsafe unsafe = Unsafe.getUnsafe();
static {
try {
// 获取偏移量
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
headOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
tailOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
waitStatusOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("waitStatus"));
nextOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("next"));
} catch (Exception ex) { throw new Error(ex); }
}
/**
* 通过原子操作 改变上锁状态
* @param expect the expected value
* @param update the new value
* @return {@code true} if successful. False return indicates that the actual
* value was not equal to the expected value.
*/
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this 调用本地方法 实现硬件级别的原子操作 cas
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}Inseguro:
1. A classe principal do CAS (comparação e troca do CAS)
2. A operação da memória através de métodos locais para obter o cas
3. Não opere essa classe no caso de um meio conhecimento
1.2 setExclusiveOwnerThread (Thread.currentThread ()); nada a dizer
1.3 AbstractQueuedSynchronizer.acquire ();
/**
* Acquires in exclusive mode, ignoring interrupts. Implemented
* by invoking at least once {@link #tryAcquire},
* returning on success. Otherwise the thread is queued, possibly
* repeatedly blocking and unblocking, invoking {@link
* #tryAcquire} until success. This method can be used
* to implement method {@link Lock#lock}.
*
* @param arg the acquire argument. This value is conveyed to
* {@link #tryAcquire} but is otherwise uninterpreted and
* can represent anything you like.
*/
public final void acquire(int arg) {
if (!tryAcquire(arg) && // 再次尝试上锁 回到了 NonfairSync.tryAcquire 方法， tryAcquire 调用了 Sync.nonfairTryAcquire方法
acquireQueued(
addWaiter(Node.EXCLUSIVE), // 链表尾部添加节点
arg
)
)
selfInterrupt();
}1.3.1 nonfairTryAcquire:
/**
* 判断 reentranLock 状态 是否被锁住（state ?= 0）
* <p>如果没被锁住尝试 原子性上锁 失败返回false</>
* <p>如果被锁住 判断是否是当前线程持有锁（重入锁的实现） 如果是 state + 1
* （信号量 记录该线程持有锁的次数。 该线程每次释放所 信号量 -1。 信号量为零 代表 锁被真正释放）</>
* <p>else 返回false</p>
* Performs non-fair tryLock. tryAcquire is implemented in
* subclasses, but both need nonfair try for trylock method.
*/
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); // 累加 state 的值 此段代码 实现了重入锁
return true;
}
return false;
}1.3.2 código addWaiter:
/**
*
* 把当前线程加入队列 尾部
*
* 负责队列初始化
* Creates and enqueues node for current thread and given mode.
*
* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
* @return the new 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;
}
}
// 列队尾部为空 或者 CAS 操作失败
enq(node);
return node;
}
/**
* Inserts node into queue, initializing if necessary. See picture above.
* @param node the node to insert
* @return node's predecessor
*/
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // 尾部不为空 不断尝试 CAS 操作
if (compareAndSetHead(new Node()))
tail = head;
} else { // 尾部为空 尝试构建表结构
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}1.3.3 PurchaseQueued
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)) { // 判断当前节点的 前驱节点 是否为队列头部 如果是 再次尝试上锁（如果头部节点 已经释放所, 则使当前线程成为持有者 并且设置自己为 头部。 同时释放前驱节点）
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt() // 进入等待状态 等待唤醒
)
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node); // TODO: 2018/1/29 抛出异常 才会走的到这里。 源码在下面
}
}
/**
* 检查 是否需要阻塞当前线程
* Checks and updates status for a node that failed to acquire.
* Returns true if thread should block. This is the main signal
* control in all acquire loops. Requires that pred == node.prev.
*
* @param pred node's predecessor holding status
* @param node the node
* @return {@code true} if thread should block
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/* 后继节点在等待唤醒 也就是当前节点需要进入等待状态了
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
if (ws > 0) { // 前驱节点被取消
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry. // 前任被取消则 将前驱节点移出列队
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/* 设置前驱节点为 SIGNAL 标记自己为等待唤醒 下次循环到这里之前 如果没有成功拥有锁， 则会进入 if (ws == Node.SIGNAL） 代码段
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this); // 又是一个底层类 实现线程等待
return Thread.interrupted(); // 返回并 取消等待状态
}
/**
* Cancels an ongoing attempt to acquire.
* 列队等待中 抛出异常会调用此方法
* @param node the node
*/
private void cancelAcquire(Node node) {
// Ignore if node doesn't exist
if (node == null)
return;
node.thread = null; // 释放线程
// 前驱节点已被取消 重新定义前驱节点
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// predNext is the apparent node to unsplice. CASes below will
// fail if not, in which case, we lost race vs another cancel
// or signal, so no further action is necessary.
Node predNext = pred.next;
// Can use unconditional write instead of CAS here.
// After this atomic step, other Nodes can skip past us.
// Before, we are free of interference from other threads.
node.waitStatus = Node.CANCELLED; // 取消当前线程 所属的节点（标记为取消）， 没有使用 cas 因为 其他线程 不会干扰这里
// If we are the tail, remove ourselves. 如果我们是尾巴，就把自己弄走
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
// If successor needs signal, try to set pred's next-link
// so it will get one. Otherwise wake it up to propagate.
// 如果node既不是tail，又不是head的后继节点
// 则将node的前继节点的waitStatus置为SIGNAL
// 并使node的前继节点指向node的后继节点（相当于将node从队列中删掉了）
int ws;
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
// 如果node是head的后继节点，则直接唤醒node的后继节点
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
/** 唤醒后继节点
* Wakes up node's successor, if one exists.
*
* @param node the node
*/
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0) //置零当前线程所在的结点状态，允许失败。
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
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); // 唤醒下级节点
}A implementação do método lock é provavelmente a acima
Pelo exposto, você provavelmente pode adivinhar como o desbloqueio funciona. . . Então escreva aqui primeiro. . . .
O resto. . . . Adivinha
