初识

ReentrantLock在并发场景下经常用到，非常重要。它是对lock接口实现的可重入锁，保证多线程安全。作用是对线程进行加锁，并且锁可重入，即一个线程获取锁后可重复获取锁而不会发生阻塞，其定义的内部类Sync继承AQS抽象类。通过AQS抽象类实现大部分的功能，小部分功能由Sync类实现，如AQS类里的tryAcquire()由子类nonfairTryAcquire()实现等等

基本使用

public static ReentrantLock lock = new ReentrantLock();

private static void add() {
        try {
            lock.lock();
            count++;
        }finally {
            lock.unlock();
        }
    }

使用new ReentrantLock即可进行实例，对需要线程安全部分首尾调用lock()进行加锁,业务代码执行完调用lock.unlock()释放锁，最好是在finally中调用解锁，以防业务代码出现问题，锁不释放带来的死锁问题。

源码解析

1.核心是AQS这个类，构造一个CLH队列，结构如图

16149389980022.jpg

2.ReentrantLock实现了Lock，以及Serializable接口，提供了两个构造方法，其中无参构造即实例一个非公平锁，有参构造方法里如果是true则构造公平锁

非公平锁，当前线程释放锁后，后续线程无需顺序竞争锁。
公平锁，当前线程释放锁后，后续线程按创建时间竞争锁。

/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

3.当直接new一个lock实例即创建一个非公平锁

/**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

NonfairSync类是Sync抽象类的一个子类，Sync下有两个子类，分别对应公平和非公平，同时继承父类AbstractQueuedSynchronizer也就是AQS，AQS类完成加锁以及阻塞队列构建和运转

关系图

16140696650757.jpg

Sync抽象类里定义的几个方法，

16140697405113.jpg

4.NonfairSync子类的lock()方法实现（非公平锁）

final void lock() {
            //4.1.首先逻辑分支语句，第一个分支使用Sync的父类AQS类里的compareAndSetState()方法来获取锁。
            //AQS类里定义一个volatile修饰的变量state;用来标识当前锁是否被占用，当没有其他线程获取锁时将state值变为1，并且调用AQS的setExclusiveOwnerThread()方法将线程所有者设置为当前线程。
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
            //4.2.如果获取锁没有成功调用AQS的acquire(1)方法。
                acquire(1);
        }

5.继上一步调用AQS的acquire(1)方法，逻辑控制语句里有两个部分，都为true时，即线程已经经历过一个完整的挂起到唤醒过程，然后再调用AQS的selfInterrupt()方法对当前线程进行标识中断（其实是对下面acquireQueued方法的一个中断补偿），具体何时中断由线程自己决定。

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

5.1.第一部分：AQS类里的tryAcquire()方法调用子类Sycn的nonfairTryAcquire()方法，入参为1。

nonfairTryAcquire()方法有三个分支。

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //第一个分支，依旧是使用cas原理获取锁，如果获取成功设置所属线程，返回true
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //第二个分支，则是ReenTrantLock的可重入性，即如果当前线程和所属线程一致，则将state值加1并且返回true。
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            //第三个分支，当上面都不能成立直接返回false。
            return false;
        }

5.2.第二部分：acquireQueued(addWaiter(Node.EXCLUSIVE), arg)首先调用addWaiter()方法，将当前线程封装成node加入到队列中

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // 判断尾结点是否存在，如果存在将新节点插入到尾结点，将尾结点指向修改为新节点。
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //如果不存在调用enq(node)方法
        enq(node);
        return node;
    }
    //将node设置为tail尾结点，此时head头节点是null
    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)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

里面addwaiter方法执行完，接下来是acquireQueued(node,1)方法

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);
                    //释放内存，帮助垃圾回收
                    p.next = null; // help GC
                    failed = false;
                    //竞争线程获取锁后，返回false，结束循环
                    return interrupted;
                }
                //下面这段主要是竞争线程获取锁失败时执行，if逻辑里有两个重要方法主要实现线程阻塞，在5.2.x里分析
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

5.2.1.shouldParkAfterFailedAcquire()方法主要是用来修正当前节点以及前驱节点的状态，并判断当前node是否可以进行安全阻塞。如果可以安全阻塞则返回true继续调用parkAndCheckInterrupt()进行阻塞中断。

volatile int waitStatus; //node节点状态，默认是0

static final int CANCELLED =  1 // waitStatus值，指示线程已取消
static final int SIGNAL    = -1 // waitStatus值，指示后续线程需要唤醒
static final int CONDITION = -2 // waitStatus值，指示线程正在等待条件

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        
        //如果前驱节点的状态是-1，返回true，表示当前node可以挂起，即上面5.2可调用parkAndCheckInterrupt()
        if (ws == Node.SIGNAL)
            return true;
            
        //如果前驱节点状态>0，则表示前驱节点已经取消，下面do while循环找到前驱节点的前驱节点，并将它设置为node的前驱节点
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
        //如果不等于-1,且>0，则将前驱节点的状态改为-1。这段方法第一次进来会执行此处。注意此时并没有去返回true来挂起当前node，而是返回false。
        //因为前驱节点状态默认是0。此方法外部自旋第二次循环才走第一个if返回true，然后开始调用parkAndCheckInterrupt()挂起当前node，即挂起竞争线程
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

5.2.2.parkAndCheckInterrupt()只做两件事 1挂起 2检查中断状态，这里特别说明下，线程挂起和线程中断不是一回事，此方法挂起线程后，代码将不再继续执行，直到线程被中断，或者被其他线程进行unpark唤醒，才能继续return。

private final boolean parkAndCheckInterrupt() {
        //挂起竞争线程。
        LockSupport.park(this);
        //如果是被unpark唤醒，即返回false，如果是被中断唤醒，返回true，重置竞争线程中断状态为false。
        return Thread.interrupted();
    }

继续parkAndCheckInterrupt()返回后进行分析。两种情况：
第一种情况，通过unpark方法唤醒，return Thread.interrupted() => false，进入acquireQueued()的自旋中，进行再次获取锁操作后。此时return的interrupted标识还是false，结束acquireQueued()后，第5步分析的selfInterrupt()的逻辑判断不成立，所以是不执行的，即没必要进行中断补偿。
第二种情况，通过中断唤醒，return Thread.interrupted() => true，进入acquireQueued()的自旋中，进行再次获取锁操作后，此时interrupted = true，第5步分析的selfInterrupt()的逻辑判断成立，进行中断补偿。

总结：到此线程的加锁流程已经分析完，如果竞争线程执行了最后一步parkAndCheckInterrupt()方法，则进入挂起状态，等待前面拥有锁的线程释放锁后，竞争线程被唤醒，再次走一遍流程去尝试获取锁，释放锁并唤醒等待线程在下一篇文章里再做源码解析。

----------------- 文章如有问题，请下方回复指出，感谢查阅😁 -----------------