1 Lock 接口分析

• Condition 实现类由 AQS 提供了，具体源码逻辑留待以后分析。。

2 AQS 抽象类结构分析

• AQS 实现了一个等待队列，用来装没有获取到锁的线程
• AQS 只实现了 没有获取锁、成功获取锁、没有释放锁、成功释放锁 后的逻辑(如何加入等待队列，如何从等待队列唤醒节点)，具体的怎样获取，怎样释放，由子类实现
• 因为 获取共享锁和获取独占锁 后的逻辑不太一样，AQS 需要分别为它们实现了相应的逻辑
• 因为公平锁、非公平锁只和 如何获取锁的逻辑 有关，对 AQS 来说是透明的，所以 AQS 不需要额外区分
• 子类 ReentrantLock：实现了公平独占锁、非公平独占锁
• 子类 ReentrantReadWriteLock：实现了公平(独占锁/共享锁)、非公平(独占锁/共享锁)
• 这里只简单的介绍 AQS 中的方法，具体的源码逻辑留待以后分析

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
   
    
    //等待队列节点类，通过这个类组成了一个等待队列
    //等待队列是 CLH 锁队列的一种变体，CLH 锁常用于自旋锁。而我们却用来实现阻塞锁，通过使用相同的策略：在节点的前节点的线程中保存一些控制信息
    //每个节点的 status 字段用来跟踪一个线程是否应该被阻塞。但一个节点的前一个节点被释放时，该节点将被通知。队列的每个节点都充当一个特定通知样式的监视器，其中包含一个等待的线程。status 字段并不控制线程是否被授予锁。
    //线程可能会尝试获取它是否在队列中的第一个。但是队列头部的线程不一定能获取锁成功，也可能重新等待
    static final class Node{
   
    ...}
    //队列的头部
    private transient volatile Node head;
    //队列的尾部
    private transient volatile Node tail;
    //锁的状态，分为高16和低16两把锁
    private volatile int state;
	//自旋 1000 纳秒
    static final long spinForTimeoutThreshold = 1000L;
    
    //--------------------- 独占模式下，获取锁失败后，如何进入队列(acquireAueued())中的逻辑
    
    //独占不响应中断模式下，获取锁失败后，如何加入队列
    public final void acquire(int arg){
   
    ...}
    //独占响应中断模式下，获取锁失败后，如何加入队列
    public final void acquireInterruptibly(int arg){
   
    ...}
    //独占有时间限制模式，获取锁失败后，如何加入队列
    public final boolean tryAcquireNanos(int arg, long nanosTimeout){
   
    ...}
    //独占模式释放锁，释放成功后，如何通知等待队列
	public final boolean release(int arg){
   
    ...}
    
    //被 acquire 调用，如果被中断返回 true
    final boolean acquireQueued(final Node node, int arg){
   
    ...}
    //被 acquireInterruptibly 调用
    private void doAcquireInterruptibly(int arg){
   
    ...}
    //被 tryAcquireNanos 调用，规定时间内获取失败返回 false，成功返回 true
    private boolean doAcquireNanos(int arg, long nanosTimeout){
   
    ...}
    

	//--------------------- 共享模式下，获取锁失败后，如何进入队列中的逻辑

    //共享不响应中断模式下，获取锁失败后，如何加入队列
    public final void acquireShared(int arg){
   
    ...}
    //共享响应中断模式下，获取锁失败后，如何加入队列
    public final void acquireSharedInterruptibly(int arg){
   
    ...}
    //共享有时间限制模式下，获取锁失败后，如何加入队列
    public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout){
   
    }
    //共享模式释下，释放锁成功后，如何通知等待队列
	public final boolean releaseShared(int arg)
        
    //--------------------- 被上面的代码调用 ---------------
    private void doAcquireShared(int arg){
   
    ...}
    private void doAcquireSharedInterruptibly(int arg){
   
    ...}
    private boolean doAcquireSharedNanos(int arg, long nanosTimeout){
   
    ...}
    private void doReleaseShared(){
   
    ...}
    
    
    //--------------------- 真正获取锁的逻辑---------由子类自定义
    //尝试获取独占锁，需要具体子类实现
	protected boolean tryAcquire(int arg)；
    //尝试释放独占锁，需要具体子类实现
	protected boolean tryRelease(int arg); 
    //尝试获取共享锁，需要具体子类实现
	protected int tryAcquireShared(int arg); 
    //尝试释放共享锁，需要具体子类实现
	protected boolean tryReleaseShared(int arg);
    
    
    //---------------------------等待队列辅助方法
    
    //插入节点到队列中
	private Node enq(final Node node){
   
    ...}
    //通过指定的 node 状态(SHARED/EXCLUSIVE)和当前线程，创建一个 node，并加入队列(里面调用了 enq 方法)
    private Node addWaiter(Node mode){
   
    ...}
    //取消该节点获取锁
    private void cancelAcquire(Node node){
   
    ...}
    //唤醒后继节点
    private void unparkSuccessor(Node node){
   
    ...}
    //检查并且更新没有获取锁成功的节点的 status，返回 true 则说明线程需要 阻塞
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node){
   
    ...}
    //挂起当前线程，返回线程中断状态，并清除中断状态
    private final boolean parkAndCheckInterrupt(){
   
    ...}
    
    //Condition 实现类，基本所有的 condition 都使用的是它！
    public class ConditionObject implements Condition, java.io.Serializable{
   
    ...}
}

3 AQS 子类 —— ReentrantLock 结构分析

• ReentrantLock 实现了获取/释放独占锁的逻辑，和 AQS 结合就形成了完整的锁

//实现了 Lock 接口，客户只能调用 Lo