并发编程（四）：AbstractQueuedSynchronizer源码分析

旧城等待， 2023-08-17 16:56 130阅读 0赞

# 一，AQS #

1，AQS是JUC的核心功能组件，主要通过FIFO双向链表特性对进行park()和unpark()操作来实现线程阻塞和线程唤醒。AQS主要提供了两种功能，独占和共享。

\* 独占锁：独占锁，每次只能有一个线程持有锁，比如ReentrantLock 就是以独占方式实现的互斥锁

\* 共享锁：允许多个线程同时持有锁，并发访问共享资源，比如ReentrantReadWriteLock.ReadLock，CountDownLatch

2，类图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70][]

\* 从主体结构看，AQS继承自 AbstractOwnableSynchronizer（获取锁的当前线程获取和设置），并实现了序列化接口。AQS内部定义了Node和ConditionObject两个内部类。其中Node类是构建AQS的FIFO双向链表的基础数据结构；ConditionObject实现了Condition接口，是基于AQS进行线程通信的基本类。

\* 其他所有JUC内涉及并发处理的类，基本的处理逻辑都是基于定义内部类Sync并继承AQS类，对AQS内部部分接口进行重写，变形为各自的业务需求；如：ReentrantLock，ReentrantReadWriteLock，CountDownLatch，Semaphore等等...

# 二，AQS的内部实现 #

1，,AQS是一个FIFO（First Inner First Outer）的双向链表，这种结构的特点是每个节点都有两个指针，分别指向当前节点的前置节点和后置节点。所以可以从任何一个节点很方便的访问前后节点，每一个节点由AQS内部类Node表示。在存在线程竞争时，每一个未竞争到锁的线程都会被封装成Node节点存储到AQS同步队列中。当当前获取到锁的线程释放锁后，会从队列中唤醒下一个阻塞的节点，以此类推。

2，Node结构如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70 1][]

\* Node节点的几种状态

// 表示共享锁
    static final Node SHARED = new Node();
    // 表示独占锁
    static final Node EXCLUSIVE = null;
    // 表示当前节点失效
    static final int CANCELLED =  1;
    // 节点初始状态，表示在FIFO双向链表构成的同步队列中等待
    static final int SIGNAL    = -1;
    // Condition单向链表队列状态
    static final int CONDITION = -2;
    // 
    static final int PROPAGATE = -3;

3，AQS阻塞队列添加节点

\* 新的线程封装成Node节点添加到AQS同步队列中，设置前置节点（prev）为之前的tail节点，并将tail节点的next节点指向当前节点

\* 通过CAS将tail节点指向当前节点

\* 此处注意是先设置的prev节点，所以在后续遍历处理的时候，是从后往前遍历，就是因为这个原因。因为从前往后，可能存在next指向命令并没有执行

4，AQS阻塞队列释放节点

\* 当存在线程释放锁后，AQS的头结点（head）会获取锁，并被AQS阻塞队列释放。

\* 修改head节点为head指向的next节点，即下一个获得锁的节点，此处CAS不需要加锁，因为是加锁的线程完成的

\* 修改新head节点的prev节点，将prev的指针指向null

#  三，AQS独占锁源码分析 #

\* AQS内部没有公平锁和非公平锁的划分，所谓公平锁和非公平锁是部分业务代码内部实现（如ReentrantLock）

##     1，从一段独占锁代码开始 ##

package com.gupao.concurrent;
    
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 独占锁演示
     * @author pj_zhang
     * @create 2019-10-01 14:28
     **/
    public class ExclusiveTest {
    
        // 定义全局重入锁对象
        private static final ReentrantLock reentrantLock = new ReentrantLock();
    
        public static void main(String[] args) {
            for (int i = 0; i < 100; i++) {
                // 遍历并启动100道线程
                Thread thread = new Thread(() -> {
                    try {
                        // 线程内部加锁并沉睡业务秒数，模拟获取到锁后不立即释放
                        reentrantLock.lock();
                        Thread.sleep(3000);
                        System.out.println(
                                Thread.currentThread().getName() + "获取锁，执行时间: "
                                        + System.currentTimeMillis());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        // finally块中释放锁
                        reentrantLock.unlock();
                    }
                }, "THREAD_" + i);
                thread.start();
                System.out.println(thread.getName() + "启动成功...");
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70 2][]

\* 从代码中我们可以看到，100道线程已经全部启动，并以三秒的频率依次执行，那这里面就会有两个疑问

\* 已经启动但是被加锁没有立即执行的线程是以什么样的方式存在？

\* 获得锁的线程执行完成后，如何通知未获得锁的线程进行线程争抢并执行？

##     2，尝试获取锁 ##

###         2.1，不带时间获取锁 ###

\* tryAcquire(int arg)

// 代码内部直接抛异常，说明该部分代码依托子类实现
    // AQS的子类实现在各个锁业务代码中处理，后续会逐一分析
    protected boolean tryAcquire(int arg) {
    	throw new UnsupportedOperationException();
    }

###         2.2，带时间获取锁 -- 该部分属于底层类，后续业务代码调用不再分析 ###

\* tryAcquireNanos(int arg, long nanosTimeout)

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
    		throws InterruptedException {
        // 判断当前线程是否已经被中断
        // 线程中断，直接抛出异常
    	if (Thread.interrupted())
    		throw new InterruptedException();
        // 通过 tryAcquire(arg) 先直接尝试获取锁，获取到直接返回true
        // tryAcquire(arg) 需要在子类中实现，此处已经不做具体分析
        // 没有获取到后，通过 doAcquireNanos 进行限时时间内获取
    	return tryAcquire(arg) ||
    		doAcquireNanos(arg, nanosTimeout);
    }

\* doAcquireNanos(int arg, long nanosTimeout)

private boolean doAcquireNanos(int arg, long nanosTimeout)
    		throws InterruptedException {
    	if (nanosTimeout <= 0L)
    		return false;
    	// 获取当前自旋结束时间，通过当前纳秒数+超时纳秒数
    	final long deadline = System.nanoTime() + nanosTimeout;
    	// 封装当前线程为Node节点，并添加的AQS同步队列队尾
    	// 此处注意Node节点的waitStatus状态为EXCLUSIVE，即表示独占
    	final Node node = addWaiter(Node.EXCLUSIVE);
    	// 是否获取到锁标志位
    	boolean failed = true;
    	try {
    		for (;;) {
    			// 获取当前节点的上一个节点
    			final Node p = node.predecessor();
    			// 如果上一个节点为head节点，并且继续尝试获取锁成功，则当前线程获取到锁
    			// FIFO队列默认存在一个head节点（不存在则第一次会创建），该头结点为空
    			if (p == head && tryAcquire(arg)) {
    				// 获取到锁后，将当前节点置为头结点，并清空头节点内容
    				setHead(node);
    				// 将头节点的next指向置为空，处理后则p节点挂空，会被GC回收
    				p.next = null; // help GC
    				// 设置failed状态为false，说明竞争锁成功
    				failed = false;
    				return true;
    			}
    			// 如果没有获取到锁，则用过期时间减去当前时间，判断剩余时间是否合法
    			nanosTimeout = deadline - System.nanoTime();
    			// 如果剩余时间小于0，时间不合法，说明线程未获取到锁
    			if (nanosTimeout <= 0L)
    				return false;
    			// 剩余时间>0时处理
    			// shouldParkAfterFailedAcquire 判断当前节点是否可以挂起，
    			// nanosTimeout > spinForTimeoutThreshold 表示如果线程剩余时间大于1000纳秒，则线程直接挂起nanosTimeout纳秒
    			if (shouldParkAfterFailedAcquire(p, node) &&
    				nanosTimeout > spinForTimeoutThreshold)
    				LockSupport.parkNanos(this, nanosTimeout);
    			// 如果线程已经中断，则线程挂起
    			if (Thread.interrupted())
    				throw new InterruptedException();
    		}
    	} finally {
    		// 如果自旋完成后，已经没有获取到锁，则将当前节点waitStatus置为失效
    		if (failed)
    			cancelAcquire(node);
    	}
    }

\* addWaiter(Node mode)：添加当前节点到AQS同步队列，该方法是一个常用底层方法，后续不再分析！这部分也是线程在AQS同步队列中的存在方式，mode会被封装为Node节点的nextWaiter属性，标识当前属性的共享还是独占

private Node addWaiter(Node mode) {
    	// 包装当前线程为Node对象，mode为传递的Node.EXCLUSIVE，表示独占锁
        // Node.EXCLUSIVE节点被包装为Node节点的nextWaiter属性，用于后续判断
    	Node node = new Node(Thread.currentThread(), mode);
    	// 将tail节点标识为前置节点
    	Node pred = tail;
    	// 判断前置节点（即tail节点）是否为空
    	// 不为空表示同步队列已经创建
    	if (pred != null) {
    		// 设置当前节点的前置节点为刚才赋值的尾结点
    		node.prev = pred;
    		// 通过CAS将tail节点替换为node节点
    		if (compareAndSetTail(pred, node)) {
    			// 将前置节点(即原tail节点)的next节点设置为当前节点
    			// 此处注意顺序问题，即先向前指向，再向后指向
    			// 所以在遍历时统一向上遍历，防止向下遍历时，存在并发导致只创建了前指，还没有创建后指时遍历不到
    			pred.next = node;
    			return node;
    		}
    	}
    	// 如果为空，则表示同步队列还没有创建，则进行创建
    	enq(node);
    	return node;
    }

\* enq(final Node node)：添加节点时，如果同步队列为空，则进行创建

private Node enq(final Node node) {
    	// 自旋进行创建
    	for (;;) {
    		// 继续获取尾结点
    		Node t = tail;
    		// 尾结点为空时，
    		// 此处如果直接不为空说明存在并发
    		if (t == null) {
    			// 创建一个空节点表示头节点，并将头节点指向尾结点
    			// 如果创建失败，说明存在并发已经创建了头节点，继续自旋走非空处理
    			// 如果创建成功，此时同步队列中只有初始化的这一个节点，此时头节点和尾结点相同
    			if (compareAndSetHead(new Node()))
    				tail = head;
    		// 尾结点不为空时
    		} else {
    			// 将尾结点设置为当前节点的上一个节点
    			node.prev = t;
    			// CAS设置当前节点为新的尾结点
    			if (compareAndSetTail(t, node)) {
    				// 设置原尾结点的下一个节点为当前节点
    				// 此处继续重视双向设置的前后问题
    				t.next = node;
    				// 最终返回上一个节点，此处在部分业务类中有应用
    				return t;
    			}
    		}
    	}
    }

\* setHead(Node node)：获取锁成功后，重新修改头节点，并将头节点置空

private void setHead(Node node) {
    	// 设置当前节点为头结点
    	head = node;
    	// 设置当前节点的thread为空，头结点只表示为一个空节点
    	node.thread = null;
    	// 设置当前节点的前置节点为空
    	node.prev = null;
    }

\* shouldParkAfterFailedAcquire(Node pred, Node node)：判断线程在竞争锁失败后是否可以挂起；线程挂起后，waitStatus为-1

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    	// 获取前置节点 waitStatus
    	int ws = pred.waitStatus;
    	// 前置节点 waitStatus 表示还在等待中，则直接挂起当前线程
    	if (ws == Node.SIGNAL)
    		return true;
    	// 前置节点 waitStatus > 0，说明 waitStatus 的状态为失效状态（CANCELLED = 1）
    	if (ws > 0) {
    		// 遍历清除所有失效的前置状态，直到找到上一个不失效的前置节点，标位当前节点前置
    		do {
    			node.prev = pred = pred.prev;
    		} while (pred.waitStatus > 0);
    		// 并把遍历到的前置节点的next节点指向当前节点
    		pred.next = node;
    	} else {
    		// 前置节点未失效，设置前置节点状态为等待，
    		compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    	}
    	// 前置节点为其他状态，基于前置节点可以快速执行完，则继续自旋等待
    	return false;
    }

\* cancelAcquire(Node node)：自旋完成后已经没有获取到锁，或线程自旋过程中被中断

private void cancelAcquire(Node node) {
    	if (node == null)
    		return;
    
    	node.thread = null;
    
    	// 自Node节点向上循环，提出已经失效节点
    	// 循环到最近的一个非失效节点停止
    	Node pred = node.prev;
    	while (pred.waitStatus > 0)
    		node.prev = pred = pred.prev;
    
    	// 获取重新赋值的前置节点的下一个节点
    	Node predNext = pred.next;
    
    	// 将当前节点的节点状态 waitStatus 置为失效
    	node.waitStatus = Node.CANCELLED;
    
    	// 如果当前节点为尾结点，则设置尾结点为刚才遍历到的前置节点
    	// 并将前置节点的next节点置为null
    	if (node == tail && compareAndSetTail(node, pred)) {
    		compareAndSetNext(pred, predNext, null);
    	// 当前节点为中间节点
    	} else {
    		int ws;
    		// 此处一串判断，主要为了判断前置节点是否头节点
    		// 如果前置节点不是头节点，且在等待中，则将前置节点的 next 节点设置为当前节点的 next 节点
    		// 当前节点被挂空移除
    		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 {
    			// 前置节点为头结点，则可能已经执行完释放锁并唤醒下一个线程
    			// 但是由于当前操作已经被链表进行了重新构造，则直接唤醒一个线程执行
    			// 下一个线程被唤醒后，会再次尝试获取锁，获取到则执行，获取不到则继续挂起
    			unparkSuccessor(node);
    		}
    
    		node.next = node; // help GC
    	}
    }

\* unparkSuccessor(Node node)：唤醒下一个有效线程

private void unparkSuccessor(Node node) {
    	// 获取当前节点的 waitStatus
    	int ws = node.waitStatus;
    	// 如果当前节点状态还在等待中，则修改为0，表示线程执行中
    	if (ws < 0)
    		compareAndSetWaitStatus(node, ws, 0);
    
    	// 获取当前线程的下一个节点，表示将要唤醒的节点
    	Node s = node.next;
    	// 如果下一个节点为空，或者节点失效
    	if (s == null || s.waitStatus > 0) {
    		s = null;
    		// 如果链表存在断层，从尾结点开始向上找，找到有效节点赋值给需要唤醒的节点
    		// 向上一直找到当前节点，则表示链表遍历了一遍，找到的有效节点即为node的下一个有效节点
    		for (Node t = tail; t != null && t != node; t = t.prev)
    			if (t.waitStatus <= 0)
    				s = t;
    	}
    	// 有效唤醒节点不为空，则唤醒当前节点所在的线程
    	if (s != null)
    		LockSupport.unpark(s.thread);
    }

##     3，加锁及加锁失败后的线程park ##

\* acquire(int arg)

public final void acquire(int arg) {
    	// tryAcquire(arg)：首先尝试获取锁
    	// addWaiter(Node.EXCLUSIVE)：尝试获取锁失败，封装当前线程为Node对象，并添加到AQS同步队列尾部，注意此处传递参数为独占锁，之前已经分析
    	// acquireQueued：线程挂起以及线程再次锁竞争
    	if (!tryAcquire(arg) &&
    		acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    		selfInterrupt();
    }

\* acquireQueued(final Node node, int arg)：独占锁被唤醒后，不会尝试去唤醒下一个节点线程

final boolean acquireQueued(final Node node, int arg) {
    	boolean failed = true;
    	try {
    		boolean interrupted = false;
            // 此处自旋，线程挂起后会阻塞
            // 等线程被唤醒，则继续循环尝试获取锁，获取锁失败，继续当前流程
            // 获取锁成功，则继续处理线程
    		for (;;) {
    			// 获取当前节点的前置节点
    			final Node p = node.predecessor();
    			// 前置节点为head节点时，再次尝试获取锁
    			if (p == head && tryAcquire(arg)) {
    				// 获取锁成功后，将当前节点置为头节点
    				setHead(node);
    				p.next = null; // help GC
    				failed = false;
    				return interrupted;
    			}
    			// shouldParkAfterFailedAcquire：获取锁失败后，判断线程是否可以挂起，之前已经分析
    			// parkAndCheckInterrupt：线程挂起，并判断线程是否已经中断，如果中断，设置中断标识为true
    			if (shouldParkAfterFailedAcquire(p, node) &&
    				parkAndCheckInterrupt())
    				interrupted = true;
    		}
    	} finally {
    		// 发生异常后，设置当前节点为失效，之前已经分析
    		if (failed)
    			cancelAcquire(node);
    	}
    }

\* parkAndCheckInterrupt()

private final boolean parkAndCheckInterrupt() {
    	// 当前线程挂起
    	LockSupport.park(this);
    	// 返回当前线程中断状态，注意：此处调用后，线程中断状态为复位，即无论当前状态是什么，返回结果后，会自动改为false
    	return Thread.interrupted();
    }

\* 线程挂起后，会等待头节点线程释放后，进行线程唤醒

##     4，尝试释放锁 ##

\* tryRelease(int arg)：该方法为实现类方法， 在具体实现类中再具体分析

protected boolean tryRelease(int arg) {
    	throw new UnsupportedOperationException();
    }

##     5，释放锁及释放后下一个节点唤醒 ##

\* release(int arg)：释放当前线程锁状态

public final boolean release(int arg) {
    	// 首先尝试释放锁，释放锁成功
    	if (tryRelease(arg)) {
    		// 获取头节点，判断头节点状态
    		// 存在等待节点的waitStatus肯定<0
    		Node h = head;
    		if (h != null && h.waitStatus != 0)
    			// 唤醒下一个等待节点
    			unparkSuccessor(h);
    		return true;
    	}
    	return false;
    }

##     6，唤醒后的线程继续执行加锁流程 ##

\* acquireQueued(final Node node, int arg)：线程唤醒后，继续自旋获取锁，获取锁成功后，隔离头节点，并将当前节点设置为头节点！接第三步

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)) {
    				// 当节点节点设置为头节点，并将头节点挂空，等待GC回收
                    // 此处注意不会唤醒下一个节点线程
    				setHead(node);
    				p.next = null; // help GC
    				failed = false;
    				return interrupted;
    			}
    			// 初次自旋，当前线程挂起
    			if (shouldParkAfterFailedAcquire(p, node) &&
    				parkAndCheckInterrupt())
    				interrupted = true;
    		}
    	} finally {
    		if (failed)
    			cancelAcquire(node);
    	}
    }

# 四，AQS共享锁源码分析 #

##     1，从一段共享锁代码开始 ##

package com.gupao.concurrent;
    
    import java.util.concurrent.CountDownLatch;
    
    /**
     * 共享锁代码演示
     * @author pj_zhang
     * @create 2019-10-01 14:36
     **/
    public class ShardTest {
    
        // 构建countDownLatch，进行全局共享锁处理
        // 传递参数为线程数量，当数量通过countDown减为0时，自定唤醒所有共享锁
        private static final CountDownLatch countDownLatch = new CountDownLatch(3);
    
        public static void main(String[] args) {
            // 循环构建线程数量，与countDownLatch限定数量一致
            for (int i = 0; i < 3; i++) {
                Thread thread = new Thread(() -> {
                    try {
                        // 标识线程已经激动，并直接进行等待，等待countDownLatch唤醒
                        System.out.println(Thread.currentThread().getName()
                                + "进入等待。。。");
                        // 通过countDownLatch等待
                        countDownLatch.await();
                        Thread.sleep(1000);
                        // 线程被唤醒后，打印线程执行时间，此时阻塞线程会基本同时执行
                        // 存在共享锁线程唤醒及线程调度时间（基本可以忽略）
                        System.out.println(Thread.currentThread().getName()
                                + "执行，时间：" + System.currentTimeMillis());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }, "THREAD_" + i);
                thread.start();
                countDownLatch.countDown();
            }
        }
    
    }

![2019100114443465.png][]

\* 从共享锁线程演示可以看出，无论是代码还是线程执行方式明显与独占锁不一致，那这里面又会有疑问

\* 基于共享锁的线程阻塞是如何实现的？

\* 共享锁的锁释放如何实现共享锁下的所有线程几乎同时执行（线程调度及线程池阻塞耗时不计算在内）？

##     2，尝试获取锁 ##

###         2.1，不带时间获取锁 ###

\* tryAcquireShared(int arg)：同样，共享锁尝试获取，基于实现类实现

protected int tryAcquireShared(int arg) {
    	throw new UnsupportedOperationException();
    }

###         2.2，带时间获取锁 ###

\* tryAcquireSharedNanos(int arg, long nanosTimeout)

public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
    		throws InterruptedException {
    	// 判断线程是否中断，中断直接抛异常
    	if (Thread.interrupted())
    		throw new InterruptedException();
    	// tryAcquireShared：尝试获取共享锁，此处依旧通过实现类实现
    	// doAcquireSharedNanos：尝试释放共享锁，在指定纳秒内
    	return tryAcquireShared(arg) >= 0 ||
    		doAcquireSharedNanos(arg, nanosTimeout);
    }

\* doAcquireSharedNanos(int arg, long nanosTimeout)

private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
    		throws InterruptedException {
    	if (nanosTimeout <= 0L)
    		return false;
    	final long deadline = System.nanoTime() + nanosTimeout;
    	// 包装当前线程为Node节点，注意此处传递参数为Node.SHARED，表示共享锁
    	final Node node = addWaiter(Node.SHARED);
    	boolean failed = true;
    	try {
    		// 自旋获取锁
    		for (;;) {
    			// 获取上一个节点
    			final Node p = node.predecessor();
    			// 前置节点为头节点
    			if (p == head) {
    				// 尝试获取共享锁
    				int r = tryAcquireShared(arg);
    				// 共享锁获取成功
    				if (r >= 0) {
    					// 设置当前节点为头节点，并递归唤醒后续共享节点，此部分后续分析
    					setHeadAndPropagate(node, r);
    					p.next = null; // help GC
    					failed = false;
    					return true;
    				}
    			}
    			// 后续定时与独占锁一致
    			nanosTimeout = deadline - System.nanoTime();
    			if (nanosTimeout <= 0L)
    				return false;
    			if (shouldParkAfterFailedAcquire(p, node) &&
    				nanosTimeout > spinForTimeoutThreshold)
    				LockSupport.parkNanos(this, nanosTimeout);
    			if (Thread.interrupted())
    				throw new InterruptedException();
    		}
    	} finally {
    		if (failed)
    			// 异常后，节点失效
    			cancelAcquire(node);
    	}
    }

##     3，加锁及加锁失败后的线程park ##

\* acquireShared(int arg)：获取共享锁

public final void acquireShared(int arg) {
    	// 尝试获取共享锁，<0说明获取失败，该部分在子类中实现
    	if (tryAcquireShared(arg) < 0)
    		// 进行锁获取处理
    		doAcquireShared(arg);
    }

\* doAcquireShared(int arg)：包装Node节点，并添加到AQS同步队列后线程挂起，唤醒后继续尝试加锁执行！加锁成功后，会判断下一个节点是否共享锁节点，如果是，会继续唤醒！

private void doAcquireShared(int arg) {
    	// 包装Node对象，注意此处传递mode为Node.SHARED
    	final Node node = addWaiter(Node.SHARED);
    	boolean failed = true;
    	try {
    		boolean interrupted = false;
    		for (;;) {
    			// 获取当前节点的前置节点
    			final Node p = node.predecessor();
    			if (p == head) {
    				// 前置节点为头节点，继续尝试获取共享锁
    				int r = tryAcquireShared(arg);
    				if (r >= 0) {
    					// 锁获取成功，设置头节点，并唤醒下一个为共享锁的节点
                        // 此处注意建立链式唤醒思想，每一个线程都在park部分被阻塞，每一个线程被唤醒后都会走这一步进行锁处理，所以每一道都会进行下一个唤醒
                        // 对共享锁来说，则存在第一个节点唤醒后，会一直链式唤醒下去，不会在存在阻塞
    					setHeadAndPropagate(node, r);
    					p.next = null; // help GC
    					if (interrupted)
    						selfInterrupt();
    					failed = false;
    					return;
    				}
    			}
    			// shouldParkAfterFailedAcquire：获取锁失败后，判断当前线程是否可以挂起
    			// parkAndCheckInterrupt：线程挂起
    			if (shouldParkAfterFailedAcquire(p, node) &&
    				parkAndCheckInterrupt())
    				interrupted = true;
    		}
    	} finally {
    		if (failed)
    			cancelAcquire(node);
    	}
    }

\* setHeadAndPropagate(Node node, int propagate)：设置头节点并唤醒下一个共享锁节点

private void setHeadAndPropagate(Node node, int propagate) {
    	// 获取头节点，并将当前节点设置为头节点
    	Node h = head;
    	setHead(node);
    	// 条件判断为有效节点
    	if (propagate > 0 || h == null || h.waitStatus < 0 ||
    		(h = head) == null || h.waitStatus < 0) {
    		Node s = node.next;
    		// 判断下一个节点是否为共享锁，如果是共享锁，则直接唤醒
    		if (s == null || s.isShared())
                            // 唤醒节点，唤醒部分详解
    			doReleaseShared();
    	}
    }

##     4，尝试释放锁 ##

\* tryReleaseShared(int arg)：该方法依旧在子类中实现

protected boolean tryReleaseShared(int arg) {
    	throw new UnsupportedOperationException();
    }

##     5，释放锁及释放后下一个节点唤醒 ##

\* releaseShared(int arg)：释放共享锁

public final boolean releaseShared(int arg) {
    	// 尝试释放共享锁
    	if (tryReleaseShared(arg)) {
    		// 共享锁释放
    		doReleaseShared();
    		return true;
    	}
    	return false;
    }

\* doReleaseShared()：唤醒下一个共享锁节点

private void doReleaseShared() {
    	// 自旋进行唤醒
    	for (;;) {
    		Node h = head;
    		if (h != null && h != tail) {
    			int ws = h.waitStatus;
    			if (ws == Node.SIGNAL) {
    				if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
    					continue;            // loop to recheck cases
    				// 直接唤醒下一个节点，
    				unparkSuccessor(h);
    			}
    			else if (ws == 0 &&
    					 !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
    				continue;                // loop on failed CAS
    		}
    		if (h == head)                   // loop if head changed
    			break;
    	}
    }

##     6，唤醒后的线程继续执行代码 ##

\* doAcquireShared(int arg)：线程被唤醒后，继续自旋获取锁，获取锁成功后进行后续节点处理

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) {
    				// 自选获取锁
    				int r = tryAcquireShared(arg);
    				if (r >= 0) {
    					// 获取锁成功，设置头节点，并唤醒后续节点
    					setHeadAndPropagate(node, r);
    					p.next = null; // help GC
    					if (interrupted)
    						selfInterrupt();
    					failed = false;
    					return;
    				}
    			}
    			if (shouldParkAfterFailedAcquire(p, node) &&
    				parkAndCheckInterrupt())
    				interrupted = true;
    		}
    	} finally {
    		if (failed)
    			cancelAcquire(node);
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70]: /images/20230809/0bbfc810b53e4edbbd81bccf32b4244e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70 1]: /images/20230809/f1866753588c4e08956cb89b18d07059.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70 2]: /images/20230809/3d98abab1af14db5ac82ef4965e390bf.png
[2019100114443465.png]: /images/20230809/be2b84c4a7cd4f5cb53980adb99cc3a8.png