万字超强图文讲解AQS以及ReentrantLock应用（建议收藏）(上）

public class ThreeSync {
    private static final Object object = new Object();
    public synchronized void normalSyncMethod(){
        //临界区
    }
    public static synchronized void staticSyncMethod(){
        //临界区
    }
    public void syncBlockMethod(){
        synchronized (object){
            //临界区
        }
    }
}

Lock lock = new ReentrantLock();
lock.lock();
try{
    ...
}finally{
    lock.unlock();
}

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

package top.dayarch.myjuc;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
 * 自定义互斥锁
 *
 * @author tanrgyb
 * @date 2020/5/23 9:33 PM
 */
public class MyMutex implements Lock {
    // 静态内部类-自定义同步器
    private static class MySync extends AbstractQueuedSynchronizer{
        @Override
        protected boolean tryAcquire(int arg) {
            // 调用AQS提供的方法，通过CAS保证原子性
            if (compareAndSetState(0, arg)){
                // 我们实现的是互斥锁，所以标记获取到同步状态（更新state成功）的线程，
                // 主要为了判断是否可重入（一会儿会说明）
                setExclusiveOwnerThread(Thread.currentThread());
                //获取同步状态成功，返回 true
                return true;
            }
            // 获取同步状态失败，返回 false
            return false;
        }
        @Override
        protected boolean tryRelease(int arg) {
            // 未拥有锁却让释放，会抛出IMSE
            if (getState() == 0){
                throw new IllegalMonitorStateException();
            }
            // 可以释放，清空排它线程标记
            setExclusiveOwnerThread(null);
            // 设置同步状态为0，表示释放锁
            setState(0);
            return true;
        }
        // 是否独占式持有
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        // 后续会用到，主要用于等待/通知机制，每个condition都有一个与之对应的条件等待队列，在锁模型中说明过
        Condition newCondition() {
            return new ConditionObject();
        }
    }
  // 聚合自定义同步器
    private final MySync sync = new MySync();
    @Override
    public void lock() {
        // 阻塞式的获取锁，调用同步器模版方法独占式，获取同步状态
        sync.acquire(1);
    }
    @Override
    public void lockInterruptibly() throws InterruptedException {
        // 调用同步器模版方法可中断式获取同步状态
        sync.acquireInterruptibly(1);
    }
    @Override
    public boolean tryLock() {
        // 调用自己重写的方法，非阻塞式的获取同步状态
        return sync.tryAcquire(1);
    }
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        // 调用同步器模版方法，可响应中断和超时时间限制
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }
    @Override
    public void unlock() {
        // 释放锁
        sync.release(1);
    }
    @Override
    public Condition newCondition() {
        // 使用自定义的条件
        return sync.newCondition();
    }
}

public void lock() {
    // 阻塞式的获取锁，调用同步器模版方法，获取同步状态
    sync.acquire(1);
}

public final void acquire(int arg) {
  // 调用自定义同步器重写的 tryAcquire 方法
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

    private Node addWaiter(Node mode) {
          // 构造Node节点，包含当前线程信息以及节点模式【独占/共享】
        Node node = new Node(Thread.currentThread(), mode);
          // 新建变量 pred 将指针指向tail指向的节点
        Node pred = tail;
          // 如果尾节点不为空
        if (pred != null) {
              // 新加入的节点前驱节点指向尾节点
            node.prev = pred;
              // 因为如果多个线程同时获取同步状态失败都会执行这段代码
            // 所以，通过 CAS 方式确保安全的设置当前节点为最新的尾节点
            if (compareAndSetTail(pred, node)) {
                  // 曾经的尾节点的后继节点指向当前节点
                pred.next = node;
                  // 返回新构建的节点
                return node;
            }
        }
          // 尾节点为空，说明当前节点是第一个被加入到同步队列中的节点
          // 需要一个入队操作
        enq(node);
        return node;
    }
    private Node enq(final Node node) {
          // 通过“死循环”确保节点被正确添加，最终将其设置为尾节点之后才会返回，这里使用 CAS 的理由和上面一样
        for (;;) {
            Node t = tail;
              // 第一次循环，如果尾节点为 null
            if (t == null) { // Must initialize
                  // 构建一个哨兵节点，并将头部指针指向它
                if (compareAndSetHead(new Node()))
                      // 尾部指针同样指向哨兵节点
                    tail = head;
            } else {
                  // 第二次循环，将新节点的前驱节点指向t
                node.prev = t;
                  // 将新节点加入到队列尾节点
                if (compareAndSetTail(t, node)) {
                      // 前驱节点的后继节点指向当前新节点，完成双向队列
                    t.next = node;
                    return t;
                }
            }
        }
    }

    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);
                      // 将哨兵节点的后继节点置为空，方便GC
                    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;
          // 如果是 SIGNAL 状态，即等待被占用的资源释放，直接返回 true
          // 准备继续调用 parkAndCheckInterrupt 方法
        if (ws == Node.SIGNAL)
            return true;
          // ws 大于0说明是CANCELLED状态，
        if (ws > 0) {
            // 循环判断前驱节点的前驱节点是否也为CANCELLED状态，忽略该状态的节点，重新连接队列
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
              // 将当前节点的前驱节点设置为设置为 SIGNAL 状态，用于后续唤醒操作
              // 程序第一次执行到这返回为false，还会进行外层第二次循环，最终从代码第7行返回
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

    private final boolean parkAndCheckInterrupt() {
          // 线程挂起，程序不会继续向下执行
        LockSupport.park(this);
          // 根据 park 方法 API描述，程序在下述三种情况会继续向下执行
          //     1. 被 unpark 
          //     2. 被中断(interrupt)
          //     3. 其他不合逻辑的返回才会继续向下执行
          // 因上述三种情况程序执行至此，返回当前线程的中断状态，并清空中断状态
          // 如果由于被中断，该方法会返回 true
        return Thread.interrupted();
    }

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

static void selfInterrupt() {
    Thread.currentThread().interrupt();
}