面试资料整理汇总
这些面试题是我朋友进阿里前狂刷七遍以上的面试资料，由于面试文档很多，内容更多，没有办法一一为大家展示出来，所以只好为大家节选出来了一部分供大家参考。
面试的本质不是考试，而是告诉面试官你会做什么，所以，这些面试资料中提到的技术也是要学会的，不然稍微改动一下你就凉凉了
在这里祝大家能够拿到心仪的offer！
共享锁除了可以多个线程共享外，在共享节点间还具有传播性。何为传播性，先看共享锁获取锁的代码：
//java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireShared
public final void acquireShared(int arg) {
//tryAcquireShared 返回-1获取锁失败，返回值大于1或者0获取锁成功
if (tryAcquireShared(arg) < 0)
//获取锁失败，进入队列操作
doAcquireShared(arg);
}
tryAcquireShared在ReentrantReadWriteLock中的实现，返回值只有两种，1表示获取锁成功，-1表示获取锁失败。在Semaphore中tryAcquireShared的返回值代表资源剩余量，返回值大于等于0表示获取锁成功，小于0表示获取锁失败。
tryAcquireShared获取锁失败后，进入AQS同步队列操作doAcquireShared。创建共享节点node，并CAS排到队列尾部，接下来判断是应该阻塞还是继续获取锁。当node的前驱节点是head时，尝试获取锁tryAcquireShared，如果获取锁成功返回值r >= 0，则执行函数setHeadAndPropagate，这个函数就是共享锁的传播性。
//java.util.concurrent.locks.AbstractQueuedSynchronizer#doAcquireShared
private void doAcquireShared(int arg) {
//创建一个读节点，并入队列
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;😉 {
final Node p = node.predecessor();
if (p == head) {
//如果前继节点是head，则尝试获取锁
int r = tryAcquireShared(arg);
if (r >= 0) {
//获取锁成功，设置新head和共享传播（唤醒后继共享节点）
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
/**
-
p不是头结点 or 获取锁失败，判断是否应该被阻塞
-
前继节点的ws = SIGNAL 时应该被阻塞
*/
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
node获取锁成功出队，设置新head，并将共享性传播给后继节点，即唤醒后继共享节点。为什么当一个节点的线程获取共享锁后，要唤醒后继共享节点？共享锁是可以多个线程共有的，当一个节点的线程获取共享锁后，必然要通知后继共享节点的线程，也可以获取锁了，这样就不会让其他等待的线程等很久，而传播性的目的也是尽快通知其他等待的线程尽快获取锁。
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
//设置node为新head
setHead(node);
/*
-
The conservatism in both of these checks may cause
-
unnecessary wake-ups, but only when there are multiple
-
racing acquires/releases, so most need signals now or soon
-
anyway.
*/
// propagate > 0，短路后面的判断
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
//唤醒后继共享节点
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
setHeadAndPropagate中调用doReleaseShared前需要一连串的条件判断，大概可以分为三部分：
1. propagate > 0
在ReentrantReadWriteLock中走到setHeadAndPropagate，只可能是propagate > 0，所以后面判断旧、新head的逻辑就被短路了。
而在Semaphore中走到setHeadAndPropagate，propagate是可以等于0的，表示没有剩余资源了，故propagate > 0不满足，往后判断。
2. h == null || h.waitStatus < 0
首先判断旧head是否为null，一般情况下是不可能是等于null，除非旧head刚好被gc了。h == null不满足，继续判断h.waitStatus < 0，h.waitStatus可能等于0，可能等于-3。
-
h.waitStatus=0的情况，某个线程释放了锁(release or releaseShared)或者前一个节点获取共享锁传播setHeadAndPropagate，唤醒后继节点的时候将h.waitStatus=-1设置为0。 -
h.waitStatus=-3，doReleaseShared唤醒head后继节点后h.waitStatus从-1到0，还没来得及更新head，即被唤醒的共享节点还没有setHeadAndPropagate，又有其他线程doReleaseShared唤醒head后继节点h.waitStatus从0到-3。
//java.util.concurrent.locks.AbstractQueuedSynchronizer#unparkSuccessor
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
//cas设置h.waitStatus -1 --> 0
compareAndSetWaitStatus(node, ws, 0);
//唤醒后继节点的线程，若为空or取消了，从tail往后遍历找到一个正常的节点
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)
//uppark线程
LockSupport.unpark(s.thread);
}
当释放共享锁or共享锁传播后会调用doReleaseShared唤醒同步队列中head的后继节点。
首先明确几个判断：
-
h.waitStatus = Node.SIGNAL，compareAndSetWaitStatus(h, Node.SIGNAL, 0))和unparkSuccessor。 -
h.waitStatus = 0，compareAndSetWaitStatus(h, 0, Node.PROPAGATE)设置head为传播模式。 -
h == head，head没有变，break中断循环；也可能被唤醒的节点立刻获取了锁出队列，导致head变了，所以继续循环唤醒head后继节点。
//java.util.concurrent.locks.AbstractQueuedSynchronizer#doReleaseShared
private void doReleaseShared() {
for (;😉 {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
//SIGNAL --> 0
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
//唤醒后继节点的线程
unparkSuccessor(h);
}
else if (ws == 0 &&
//0 --> PROPAGATE
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
/**
-
we must loop in case a new node is added
-
while we are doing this
*/
if (h == head) // loop if head changed
//head没有变则break
break;
}
}
3. (h = head) == null || h.waitStatus < 0
首先判断新head是否为空，一般情况下新head不为空，(h = head) == null不满足，判断h.waitStatus < 0，h.waitStatus可能等于0，可能小于0（-3 or -1）。
-
h.waitStatus可能等于0的情况，后继节点刚好入队列，还没有走到shouldParkAfterFailedAcquire()中的修改前继节点waitStatus的代码。 -
h.waitStatus=-3，上一个共享节点被唤醒后，成为新head，后继节点刚入队列，又有其他线程释放锁调用doReleaseShared，h.waitStatus从0改为-3。 -
h.waitStatus=-1，已经调用了shouldParkAfterFailedAcquire()，h.waitStatus从0 or -3 改为-1，可能阻塞，可能未阻塞。
//java.util.concurrent.locks.AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire
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.
-
node拿锁失败，前继节点的状态是SIGNAL，node节点可以放心的阻塞，
-
因为下次会被唤醒
*/
return true;
if (ws > 0) {
/*
-
Predecessor was cancelled. Skip over predecessors and
-
indicate retry.
-
pred节点被取消了，跳过pred
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/* 0 -3
-
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;
}
接下来通过控制变量法，求证共享锁的传播性。
对于ReentrantReadWriteLock，既然走到了setHeadAndPropagate，tryAcquireShared返回值就一定大于0，即propagate > 0，所以对于ReentrantReadWriteLock，PROPAGATE只是一个中间状态值，即使没有PROPAGATE也不会影响共享锁的传播性。
而Semaphore具有资源的概念，走到setHeadAndPropagate，tryAcquireShared返回值代表资源剩余量，返回值可能等于0，所以需要配合状态PROPAGATE完成共享锁的传播性。
接下来只讨论Semaphore的传播情况。
（1）假设Semaphore有10个资源都被占用。A线程获取资源失败入队列阻塞。此时C释放资源，唤醒A（h.ws=-1 ---> h.ws=0）。A获取资源成功，但是没有资源了，tryAcquireShared返回0（p=0）。此时B线程获取资源失败进入队列，但是还没有阻塞（A.ws=0）。
p>0不满足，h==null || h.ws < 0 不满足，h=head==null || h.ws < 0不满足。都不满足，A线程执行setHeadAndPropagate不唤醒B线程，因为没有资源了，没必要唤醒。
（2）在（1）的基础上，当判断完3个条件后，D线程释放资源，B还没有阻塞，B也无需被D唤醒，B在阻塞前还有一次重试的机会；在D释放资源前，B已经阻塞了，就由D唤醒B。
（3）在（1）的基础上，当在判断3个条件前，B已经阻塞了，h=head==null || h.ws < 0判断新head满足条件，A唤醒B，B可能因为没有资源而获取资源失败继续阻塞，造成了不必要的唤醒，也可能因为此时刚好有线程释放了资源，B获取资源出队列。
（4）在（1）的基础上，C唤醒A后，A获取锁成功，tryAcquireShared返回0，A还未出队列，此时B又刚好获取锁失败进入队列。此时D释放资源h.ws=0 ---> h.ws=-3。p>0不满足，h==null || h.ws < 0满足，执行doReleaseShared唤醒B。B还没有阻塞没必要唤醒，若B没有抢过其他线程而阻塞，此时唤醒B，B可能因为没有资源而获取资源失败继续阻塞，造成了不必要的唤醒，也可能因为此时刚好有线程释放了资源，B获取资源出队列。
最后
整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。
其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣，
ze_16,color_FFFFFF,t_70#pic_center)
最后
整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。
[外链图片转存中…(img-flCq9v7G-1715811335962)]
[外链图片转存中…(img-wascCGQV-1715811335962)]
其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣，
610
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
