参考的原文链接：https://blog.csdn.net/anlian523/article/details/106344926
目录
（源码的主要分析在我的其它的总结，本文补充说明各种结构和细节上面的学习总结,还有就是框架的一个梳理，参考学习的文章是上面的链接，说的非常细节）
黑马并发编程（AQS源码分析、线程池）
黑马并发编程JUC（信号量、线程安全类）总结
黑马并发编程JUC总结
独占锁源码解析
重要变量（AQS）
private transient Thread exclusiveOwnerThread;//独占锁线程,在父类AbstractOwnableSynchronizer
private volatile int state;//在AQS中
队列节点结构
- 双向链表，而且有一个nextWaiter来表示节点是共享还是独占
static final class Node {
//共享锁的时候创建的节点
static final Node SHARED = new Node();
//独享锁节点
static final Node EXCLUSIVE = null;
//节点删除状态
static final int CANCELLED = 1;
//提醒状态，说明后面有节点需要被唤醒
static final int SIGNAL = -1;
//处在条件队列
static final int CONDITION = -2;
//我的理解是传播状态，提醒还有共享锁，防止重复唤醒
static final int PROPAGATE = -3;
volatile int waitStatus;
//双向链表结构
volatile Node prev;
volatile Node next;
//Node的包装的线程
volatile Thread thread;
//表明Node是shared还是独占锁，但是不参与队列中
Node nextWaiter;
final boolean isShared() {
return nextWaiter == SHARED;
}
}
AQS持有队列
- head是null，也就是dummyNode
- 等待线程一个，但是节点肯定有两个
private transient volatile Node head;
/**
* Tail of the wait queue, lazily initialized. Modified only via
* method enq to add new wait node.
*/
private transient volatile Node tail;
Unsafe
通过unsafe来修改变量,防止出现并发问题
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;
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); }
}
/**
* CAS head field. Used only by enq.
*/
private final boolean compareAndSetHead(Node update) {
return unsafe.compareAndSwapObject(this, headOffset, null, update);
}
/**
* CAS tail field. Used only by enq.
*/
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
/**
* CAS waitStatus field of a node.
*/
private static final boolean compareAndSetWaitStatus(Node node,
int expect,
int update) {
return unsafe.compareAndSwapInt(node, waitStatusOffset,
expect, update);
}
/**
* CAS next field of a node.
*/
private static final boolean compareAndSetNext(Node node,
Node expect,
Node update) {
return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
}
ReentantLock的内部类
- Sync继承AQS，并且实现了tryRelease，父类实现抛出异常
- FairSync和nonFairSync继承Sync，公平和非公平，实现了tryAcquire，父类实现抛出异常
public class ReentrantLock implements Lock, java.io.Serializable {
private final Sync sync;
abstract static class Sync extends AbstractQueuedSynchronizer {
...
}
static final class NonfairSync extends Sync{
...
}
static final class FairSync extends Sync {
...
}
// 默认是非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
// 根据参数，设置公平或非公平
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
// 获取锁
public void lock() {
sync.lock();
}
...
}
ReentrantLock的公平和是否能够中断
- 实现了AQS的独占锁
- 公平与非公平锁
- 能不能够中断
第一个实现公平和不响应阻断FairSync同步器（说说lock的过程?）
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
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;
}
}
acquire分析
- tryAcquire尝试获取锁，如果成功就是true，否则false
- acquireQueue不断尝试tryAcquire，中间会有阻塞和唤醒
- addWaiter把需要等待的线程加入队列。
- selfInterrupt重新设置中断状态，阻塞期间线程被中断，但是中断状态被消耗。需要重新设置
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
tryAcquire分析
- 判断锁是否被用了，如果是c==0说明没有那么就需要看看阻塞队列是否有线程排队，如果没有才能够设置当前线程获取锁。给锁设置owner
- 接着就是判断是不是可重入锁。用set的原因是这里只能是一个线程，之前的是因为可能多个线程竞争需要CAS
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;
}
addWaiter
- 把节点加到队尾
- 如果发现tail是空的执行enq实际上就是创建tail然后再把节点放入节点后逻辑基本上一样。也有可能是CAS失败，重新进入enq来把节点加入到队尾。使用了自旋+CAS
为什么需要要使用双向队列和tail指针？
- 新节点node（多个，因为有多个线程执行添加节点）的prev指向tail
- tail改成其中抢占成功的线程节点。但是这个时候前一个tail没有指向下一个新节点导致从前面往后面遍历导致漏掉了一个
- 但是现在的tail往前面遍历使用prev指针就能正确遍历。
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;
}
private Node enq(final Node node) {
for (;;) {
Node t = tail;
//初始化尾节点
if (t == null) {
// Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
//把tail指向新加入的那个节点
t.next = node;//t指向的是前一个tail
return t;
}
}
}
}
acquireQueue
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
// 尝试获取锁的前提是node是head的后继
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);
}
}
acquireQueued
实际上就是不断通过for循环来tryAcquire获取锁，至少执行两次，才会被阻塞，阻塞之后能被前驱节点唤醒再次进入循环
- 尝试不断获取锁，但是前提是前一个节点是head
- 线程可以被中断，但是最后不会执行cancelAcquire。也就是AQS使用者是不被中断的。
- setHead处理的阻塞之后获取锁的节点为head。head之所以为null是因为当前线程已经成功放入owner
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)) {
//把当前节点设置为dummyNode
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}
shouldParkAfterFailedAcquire
- 判断前驱节点是不是signal如果是就返回true，如果不是那么就会往前找
- 如果ws>0说明节点是CANCELLED不再等待那么就要循环找到0或者是PROPAGATE的节点设置为signal提醒这个节点后面需要它去唤醒后驱节点。
- 死循环保证了一定能够修改状态
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 {
/*
* 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;
}
parkAndCheckInterrupt分析
- 使用的是LockSupport.park来进行阻塞。
- Thread.interrupt如果期间被中断那么就会重新唤醒，并且清除中断状态，把acquireQueued中的interrupted改为true最后返回到acquire的结果就是true，然后调用一次中断状态，可能线程需要使用。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
非公平、响应阻断同步器NonFairSync
- 非公平锁和公平锁唯一的不同就是一开始的lock是先尝试改变状态然后再acquire。如果直接lock成功就能够直接插队
- nonfairTryAcquire唯一不同的地方就是不需要看是否有阻塞队列直接开始插队。但是tryAcquire就需要看是不是有阻塞队列
//ReentrantLock.java
abstract static class Sync extends AbstractQueuedSynchronizer {
...
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;
}
...
}
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
final void lock() {
// if分支里的逻辑只是一次快速尝试
// 它和nonfairTryAcquire里的部分逻辑是一样的
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
// 将nonfairTryAcquire的逻辑直接放在这里，就把公平锁看起来一样了
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;
}
响应中断、独占锁的获取
- 对比不可中断，这里lockInterruptly是直接调用acqurieInterruptibly而不是acquire。
- 如果发现调用的时候线程被中断立刻抛出异常
- 如果没有抛出异常那么执行doAcquireInterruptibly相当于就是acquireQueue。但是它没有返回值，因为它并不需要通知线程的中断状况，而是能够直接中断抛出异常
- 而且能够调用cancelAcquire，相当于就是从队列中删除节点，而且删除节点相当于就是设置了闹钟，首先就是要获取准备删除node节点的pred前驱。获取前驱之后为了防止可能出现pred被中间中断，变成cancelled和突然变成头结点（pred线程占了锁），并且还要判断线程在不在来判断是不是真的变成了头结点，还有可能是节点CAS变成signal失败那么就跟应该释放node，因为如果没有释放node，那么pred根本不会唤醒node，如果这些都不符合那么node的后继可安心睡觉被连接，如果符合就直接唤醒node，让后继走向第一个节点。
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public final void acquireInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
//变成了抛出异常，那么finally的failed就是true可以执行cancel
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
private void cancelAcquire(Node node) {
// Ignore if node doesn't exist
if (node == null)
return;
node.thread = null;
//循环取出队列的有效前驱节点,>0是cancel，其他小于等于0的是有效节点
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
//为了删除node，这个时候pred的next其实就是node，防止其他节点访问到它
Node predNext = pred.next;
//设置节点状态为正在删除，防止其他线程在添加节点的时候把它设置signal导致后面没办法唤醒线程。
node.waitStatus = Node.CANCELLED;
//如果node节点是尾部，那么就直接设置next是null
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
//如果是中间节点，那么就直接跨过它，前驱节点的next就是node.next
int ws;
if (pred != head &&//判断是不是头结点，如果是，那么就唤醒node，唤醒node让它自动走出队列
((ws = pred.waitStatus) == Node.SIGNAL ||//如果ws不是signal而且设置waitStatus失败的话，那么相当于pred的状态可能还是cancel那么也只能唤醒node出队，让后继成为第一个节点
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
//如果pred的线程是空的那么也是说pred是头结点，那么就唤醒node让node的后继作为第一个节点
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
超时锁获取
tryLock
- 和lockInterruptibly不一样的地方就是它加上了超时时间，或者是只会尝试一次就结束循环。
- tryLock之后就是调用tryAcquireNacos这里首先就是调用tryAcquire（可以是公平或者是不公平获取锁），如果不行那么才会执行doAcquireNanos
- doAcquireNanos和doAcquireInterruptibly的区别就是Nacnos多了一个死期计算，如果到达死期或者是已经超过死期那么就会自动结束循环
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
//定时获取锁，如果超时就结束
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())//可以直接被中断
throw new InterruptedException();
return tryAcquire(arg) ||//先尝试获取锁
doAcquireNanos(arg, nanosTimeout);//进入阻塞队列
}
private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (nanosTimeout <= 0L)
return false;
final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return true;
}
//计算超时时间，死期
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)//超过1ms
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
说说独享锁释放的过程(说说unlock的过程)？
release
- unlock之后第一个调用的函数，尝试tryRelease，然后就是唤醒下一个节点。
public void unlock() {
sync.release(1);
}
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
- 如果没有获取锁的情况release那么就会抛出异常，指的是没有锁的时候unlock
- 接着就是释放锁或者是减少可重入锁，知道state为0的时候才是释放锁的时候
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
//防止没锁的时候unlock
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
//释放锁
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
unparkSuccessor
- 获取当前节点的状态，如果是<0说明就是signal那么就可以把状态改为0。说明已经开始唤醒下一个线程
- 取出下一个节点，如果s==null说明这里的next还没有赋值，说明还在加入到队列中，那么可以通过tail往前面找，利用pred的有效性找到对应的节点（其实还是node的下一个节点）。
- 中找到之后那么就执行unpark这个节点的线程。
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) {
//next还没有设置
s = null;
//利用pred的有效性,往前面找
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)//唤醒前一个节点
LockSupport.unpark(s.thread);
}
unparkSuccessor
- 获取当前节点的状态，如果是<0说明就是signal那么就可以把状态改为0。说明已经开始唤醒下一个线程
- 取出下一个节点，如果s==null说明这里的next还没有赋值，说明还在加入到队列中，那么可以通过tail往前面找，利用pred的有效性找到对应的节点（其实还是node的下一个节点）。
- 中找到之后那么就执行unpark这个节点的线程。
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) {
//next还没有设置
s = null;
//利用pred的有效性,往前面找
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)//唤醒前一个节点
LockSupport.unpark(s.thread);
}