可重入锁

这里以非公平锁作为演示，非公平锁和公平锁的区别在于未进队列之前，无差别尝试上错的，进了队列两者是一样的

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

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;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}

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);
}
}
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状态，这个会使刚上任的头结点从0变为-1（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;
}