ReentrantLock 源码分析

ReentrantLock

1）ReentrantLock 类实现了和 synchronized 一样的内存语义，同时该类提供了更加灵活多样的可重入互斥锁定操作。
2）ReentrantLock 实例可以被同一个线程多次获取，因此是可重入的互斥锁。

实例创建

    /**
     * 创建一个非公平的可重入互斥锁实例
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * fair=true：创建一个公平的可重入互斥锁实例，谁先加入同步队列谁先获取锁。
     * fair=false：创建一个非公平的可重入互斥锁实例
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

读取锁【非公平锁】

    /**
      * 1）如果该可重入互斥锁没有被另一个线程保持，则获取该可重入互斥锁并立即返回，
      * 将可重入互斥锁的保持计数设置为 1。
      * 2）如果当前线程已经持有该可重入互斥锁，则将保持计数加 1，并且该方法立即返回。
      * 3）如果该可重入互斥锁被另一个线程保持，当前线程将阻塞等待获取可重入互斥锁。
      */
    public void lock() {
        sync.acquire(1);
    }

AbstractQueuedSynchronizer#acquire
    /**
     * 1）在独占模式下获取锁，忽略中断【线程被中断后，当尝试获取锁时会被清除中断状态并重新进入阻塞模式】
     * 2）首先尝试进行一次锁获取，如果获取成功则直接返回；
     * 如果获取失败，则将当前线程加入同步队列中阻塞等待获取锁。
     */
    public final void acquire(int arg) {
        /**
         * 1）tryAcquire 首先尝试获取锁，获取成功则直接返回
         * 2）获取失败后，通过 addWaiter 创建一个独占模式的节点，
         * 并将当前线程驻留其上，通过 acquireQueued 将该节点加入同步队列阻塞等待获取锁。
         * 3）如果尝试获取锁时线程被设置了中断标识，则当期线程中断自己。
         */
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
            AbstractQueuedSynchronizer.selfInterrupt();
        }
    }

    /**
     * 非公平锁的同步对象
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        protected boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    /**
     * ReentrantLock 锁的同步控制基础类
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * 非公平地尝试获取锁操作
         */
        @ReservedStackAccess
        final boolean nonfairTryAcquire(int acquires) {
            // 读取当前线程
            final Thread current = Thread.currentThread();
            // 读取同步状态值
            final int c = getState();
            // 1）如果同步状态为 0，表示没有线程持有锁
            if (c == 0) {
                // 尝试原子更新同步状态为 acquires，此处是 1
                if (compareAndSetState(0, acquires)) {
                    // 如果设置成功，则表示当前线程获取锁成功，则设置同步器的独占线程为当前线程
                    setExclusiveOwnerThread(current);
                    // 成功获取锁返回 true
                    return true;
                }
            }
            // 2）判断持有锁的线程是否是当前线程
            else if (current == getExclusiveOwnerThread()) {
                // 如果是当前线程，则表示锁重入，递增同步状态值
                final int nextc = c + acquires;
                // 同步状态值溢出
                if (nextc < 0) {
                    throw new Error("Maximum lock count exceeded");
                }
                // 更新同步状态值
                setState(nextc);
                // 成功获取锁返回 true
                return true;
            }
            // 锁已经被其他线程持有，获取失败则 false
            return false;
        }
    }

AbstractQueuedSynchronizer#Node
    /**
     * 同步器队列节点
     */
    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;
        /**
         * 下一次 acquireShared 操作需要被无条件往后传播，用于锁共享模式下
         */
        static final int PROPAGATE = -3;

        /**
         * 同步器状态值
         *   SIGNAL: 当前节点的后继节点上驻留的线程被阻塞，当前节点被释放或取消时，
         *      必须唤醒其后继节点上驻留的线程。
         *   CANCELLED: 当前节点由于超时或线程被中断而取消，节点永远不会离开该状态，
         *      被取消的节点不会再次阻塞。
         *   CONDITION: 当前节点位于条件队列，当满足条件时，该节点的同步状态会被设置为 0，
         *      并转移到同步队列中。
         *   PROPAGATE: releaseShared 操作需要被无条件向后传播，该值只能设置在头节点上。
         *   0: 同步队列节点的初始状态。
         *
         * 非负值表示节点不需要信号【节点被取消】，在某些场景下可以简化使用。
         * 同步队列节点的初始同步状态为 0，条件队列节点的初始同步状态为 -2.
         */
        volatile int waitStatus;

        /**
         * 同步队列节点的前置节点，在入队列时设置，在出队列时设置为 null.
         */
        volatile Node prev;

        /**
         * 同步队列节点的后置节点，在绕过取消的节点时更新，在节点出队列时置为 null。
         * 被取消节点的 next 值被设置为节点本身。
         */
        volatile Node next;

        /**
         * 驻留在节点的线程，在创建时设置，在使用后置为 null。
         */
        volatile Thread thread;

        /**
         * 1）条件队列只在独占模式下被访问，nextWaiter 值为下一个在条件上等待的节点。
         * 2）如果值为 SHARED，则表示该节点处于共享模式。
         */
        Node nextWaiter;

        /**
         * 节点处于共享模式，则返回 true
         */
        boolean isShared() {
            return nextWaiter == Node.SHARED;
        }

        /**
         * 读取当前节点的前置节点
         */
        Node predecessor() {
            final Node p = prev;
            if (p == null) {
                throw new NullPointerException();
            } else {
                return p;
            }
        }

        /** Establishes initial head or SHARED marker. */
        Node() {}

        /** Constructor used by addWaiter. */
        Node(Node nextWaiter) {
            // 设置下一个等待节点
            this.nextWaiter = nextWaiter;
            // 将当期线程驻留其上
            Node.THREAD.set(this, Thread.currentThread());
        }

        /** Constructor used by addConditionWaiter. */
        Node(int waitStatus) {
            Node.WAITSTATUS.set(this, waitStatus);
            Node.THREAD.set(this, Thread.currentThread());
        }

        /** 尝试更新同步状态 */
        boolean compareAndSetWaitStatus(int expect, int update) {
            return Node.WAITSTATUS.compareAndSet(this, expect, update);
        }

        /** 尝试更新当前节点的后置节点 */
        boolean compareAndSetNext(Node expect, Node update) {
            return Node.NEXT.compareAndSet(this, expect, update);
        }

        // 设置当前节点的前置节点
        void setPrevRelaxed(Node p) {
            Node.PREV.set(this, p);
        }

        // VarHandle mechanics
        private static final VarHandle NEXT;
        private static final VarHandle PREV;
        private static final VarHandle THREAD;
        private static final VarHandle WAITSTATUS;
        static {
            try {
                final MethodHandles.Lookup l = MethodHandles.lookup();
                NEXT = l.findVarHandle(Node.class, "next", Node.class);
                PREV = l.findVarHandle(Node.class, "prev", Node.class);
                THREAD = l.findVarHandle(Node.class, "thread", Thread.class);
                WAITSTATUS = l.findVarHandle(Node.class, "waitStatus", int.class);
            } catch (final ReflectiveOperationException e) {
                throw new Error(e);
            }
        }
    }

AbstractQueuedSynchronizer#addWaiter
    /**
     * 以指定的模式 mode 创建节点，并将当前线程驻留其上，之后将该节点加入同步队列。
     */
    private Node addWaiter(Node mode) {
        // 创建节点并驻留当前线程
        final Node node = new Node(mode);

        for (;;) {
            // 读取尾节点
            final Node oldTail = tail;
            // 1）尾节点不为 null，则直接将该节点加入到同步队列尾部
            if (oldTail != null) {
                // 设置前置节点
                node.setPrevRelaxed(oldTail);
                // 比较设置尾部节点
                if (compareAndSetTail(oldTail, node)) {
                    // 设置成功，则更新旧尾节点的 next 为当前节点【新尾节点】
                    oldTail.next = node;
                    // 返回当前节点
                    return node;
                }
                // 2）初始化同步队列
            } else {
                initializeSyncQueue();
            }
        }
    }

AbstractQueuedSynchronizer#initializeSyncQueue
    /**
     * 在第一次发生锁竞争时初始化同步队列的头、尾节点，
     * 同步队列的头节点是一个傀儡节点，不驻留线程，新建时同步状态为 0，
     * 阻塞节点加入队列后，同步状态被设置为 -1.
     */
    private final void initializeSyncQueue() {
        Node h;
        // 原子设置头结点为新建节点
        if (AbstractQueuedSynchronizer.HEAD.compareAndSet(this, null, h = new Node())) {
            // 设置为节点为新建节点
            tail = h;
        }
    }

AbstractQueuedSynchronizer#acquireQueued
    /**
     * 在独占、线程不可中断的模式下获取锁，当前线程已经在同步队列中。
     */
    final boolean acquireQueued(final Node node, int arg) {
        boolean interrupted = false;
        try {
            for (;;) {
                // 读取当前节点的前置节点
                final Node p = node.predecessor();
                // 如果前置节点是 head，则尝试获取锁
                if (p == head && tryAcquire(arg)) {
                    // 获取成功，则设置当前节点为 head
                    setHead(node);
                    p.next = null; // help GC
                    // 返回线程中断标识
                    return interrupted;
                }
                // 当前线程是否需要被阻塞
                if (AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire(p, node)) {
                    // 阻塞当前线程，并等待唤醒，唤醒后返回其中断状态
                    interrupted |= parkAndCheckInterrupt();
                }
            }
        // 线程运行过程中出现异常
        } catch (final Throwable t) {
            // 取消当前节点
            cancelAcquire(node);
            // 如果线程被设置中断标识
            if (interrupted) {
                // 则线程自我中断
                AbstractQueuedSynchronizer.selfInterrupt();
            }
            throw t;
        }
    }

AbstractQueuedSynchronizer#shouldParkAfterFailedAcquire
    /**
     * 判断并更新前置节点的状态，如果线程需要被阻塞，则返回 true
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        // 读取前置节点的同步状态
        final int ws = pred.waitStatus;
        // 1）前置节点已经是 Node.SIGNAL，最后入队的节点被取消而踢除时出现。
        if (ws == Node.SIGNAL) {
            // 当前线程需要被阻塞，则返回 true
            return true;
        }
        // 2）前置节点已经被取消
        if (ws > 0) {
            // 将被取消的前置节点踢除，直到遇到一个需要信号的节点为止
            do {
                // 踢除前置节点
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            // 将当前节点链接到新的前置节点后
            pred.next = node;
        } else {
            /**
             * waitStatus must be 0 or PROPAGATE.
             * 将前置节点设置为 Node.SIGNAL，表示当前置节点被释放时，需要唤醒当前节点
             * 再次获取锁失败时，当前节点将阻塞等待。
             */
            pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
        }
        // 线程不需要被阻塞，再次尝试获取锁
        return false;
    }

AbstractQueuedSynchronizer#parkAndCheckInterrupt
    /**
     * 阻塞当前线程，并在线程被释放时【正常释放或被其他线程中断】
     * 返回中断状态。
     */
    private final boolean parkAndCheckInterrupt() {
        // 阻塞当前线程
        LockSupport.park(this);
        // 返回并清除线程中断状态
        return Thread.interrupted();
    }

LockSupport#park
    /**
     * 在许可可用之前阻塞当前线程。
     * 如果许可可用，则使用该许可，并且该调用立即返回；否则，当前线程将被阻塞。
     * 以下场景下该方法调用才会返回：
     * 1）其他某个线程调用将当前线程作为目标调用 unpark。
     * 2）其他某个线程中断当前线程。
     * 3）该调用不合逻辑地（即毫无理由地）返回。
     */
    public static void park(Object blocker) {
        // 读取当前线程
        Thread t = Thread.currentThread();
        // 设置 Thread 的 parkBlocker 属性为阻塞者 blocker
        setBlocker(t, blocker);
        // 阻塞当前线程
        U.park(false, 0L);
        // 线程被重新调度，则置空当前线程的 parkBlocker
        setBlocker(t, null);
    }

Unsafe#park
    /**
     * 阻塞当前线程
     * 1）isAbsolute=false，time=0：直到其他线程调用 LockSupport#unpark 方法唤醒
     * 目标线程，或目标线程被其他线程中断。
     * 2）isAbsolute=false，time>0：除了线程被主动唤醒、线程被中断之外，指定的纳秒时间已经过去
     * ，则线程被自动唤醒。
     * 3）isAbsolute=true，time>0：除了线程被主动唤醒、线程被中断之外，
     * 当前时间已经超过指定 Epoch 的时间戳，则线程被自动唤醒。
     * 4）异常情况下被唤醒
     */
    @HotSpotIntrinsicCandidate
    public native void park(boolean isAbsolute, long time);

AbstractQueuedSynchronizer#cancelAcquire
    /**
     * 1）被取消节点是尾节点，则直接踢除
     * 2）被取消节点是第一个需要获取锁的节点，则唤醒其后置节点
     * 3）被取消节点在中间，则将前置节点和后置节点相连
     * 取消正在进行的获取锁操作
     */
    private void cancelAcquire(Node node) {
        // 节点已经不存在，则直接返回
        if (node == null) {
            return;
        }

        // 清除节点驻留线程
        node.thread = null;

        // 跳过被取消的前置节点
        Node pred = node.prev;
        while (pred.waitStatus > 0) {
            node.prev = pred = pred.prev;
        }

        // predNext is the apparent node to unsplice. CASes below will
        // fail if not, in which case, we lost race vs another cancel
        // or signal, so no further action is necessary.
        final Node predNext = pred.next;

        // 设置节点的同步状态为已经取消
        node.waitStatus = Node.CANCELLED;

        // 1）当前节点是尾节点，则比较更新尾部接地啊
        if (node == tail && compareAndSetTail(node, pred)) {
            // 尾部节点更新成功后，比较更新尾节点的 next 属性
            pred.compareAndSetNext(predNext, null);
        // 2）当前节点不是尾节点
        } else {
            /**
             * 1）前置节点不是头节点，并且前置节点的同步状态为 Node.SIGNAL【
             * 如果同步状态<=0，则将其设置为 Node.SIGNAL】，
             * 并且前置节点的驻留线程不为 null【不是傀儡节点】。
             */
            int ws;
            if (pred != head &&
                    ((ws = pred.waitStatus) == Node.SIGNAL ||
                    ws <= 0 && pred.compareAndSetWaitStatus(ws, Node.SIGNAL)) &&
                    pred.thread != null) {
                // 读取后置节点
                final Node next = node.next;
                // 后置节点不为 null，并且其需要信号
                if (next != null && next.waitStatus <= 0) {
                    // 则比较更新前置节点的 next 属性
                    pred.compareAndSetNext(predNext, next);
                }
            /**
             * 2）前置节点是头节点，说明当前节点是需要获取锁的第一个节点，
             * 当前节点被取消，需要唤醒其后继节点。
             */
            } else {
                unparkSuccessor(node);
            }
            // 被取消节点的 next 设置为节点本身
            node.next = node; // help GC
        }
    }

AbstractQueuedSynchronizer#unparkSuccessor
    /**
     * 如果后继节点存在，则唤醒驻留其上的线程
     */
    private void unparkSuccessor(Node node) {
        // 读取节点同步状态
        final int ws = node.waitStatus;
        // 节点需要信号，则比较更新为 0
        if (ws < 0) {
            node.compareAndSetWaitStatus(ws, 0);
        }

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        /**
         * 读取后置节点
         */
        Node s = node.next;
        // 后置节点为 null 或后置节点已经被取消
        if (s == null || s.waitStatus > 0) {
            s = null;
            /**
             * 从尾部开始遍历，如果迭代节点不是当前节点，并且其不为 null，则进入循环体。
             * 一旦遇到当前节点或前置节点为 null【遍历到头部】，则退出循环。
             * 遍历完成之后，可以获取到当前节点后，第一个需要被唤醒的节点【如果存在】
             */
            for (Node p = tail; p != node && p != null; p = p.prev) {
                // 迭代节点需要信号
                if (p.waitStatus <= 0) {
                    // 则更新需要被唤醒的节点
                    s = p;
                }
            }
        }
        // 目标节点存在
        if (s != null) {
            // 则唤醒驻留其上的线程
            LockSupport.unpark(s.thread);
        }
    }

LockSupport#unpark
    /**
     * 给当前线程一个许可，如果当前线程被阻塞，则将其唤醒；
     * 如果线程已经被唤醒，则下一次调用 park 操作形参 Thread 将不会被阻塞。
     */
    public static void unpark(Thread thread) {
        if (thread != null) {
            // 唤醒目标线程
            LockSupport.U.unpark(thread);
        }
    }

获取锁【公平锁】

    /**
     * 1）如果该可重入互斥锁没有被另一个线程保持，则获取该可重入互斥锁并立即返回，
     * 将可重入互斥锁的保持计数设置为 1。
     * 2）如果当前线程已经持有该可重入互斥锁，则将保持计数加 1，并且该方法立即返回。
     * 3）如果该可重入互斥锁被另一个线程保持，当前线程将阻塞等待获取可重入互斥锁。
     */
    @Override
    public void lock() {
        sync.acquire(1);
    }

AbstractQueuedSynchronizer#acquire
    /**
     * 1）在独占模式下获取锁，忽略中断【线程被中断后，当尝试获取锁时会被清除中断状态并重新进入阻塞模式】
     * 2）首先尝试进行一次锁获取，如果获取成功则直接返回；
     * 如果获取失败，则将当前线程加入同步队列中阻塞等待获取锁。
     */
    public final void acquire(int arg) {
        /**
         * 1）tryAcquire 首先尝试获取锁，获取成功则直接返回
         * 2）获取失败后，通过 addWaiter 创建一个独占模式的节点，
         * 并将当前线程驻留其上，通过 acquireQueued 将该节点加入同步队列阻塞等待获取锁。
         * 3）如果尝试获取锁时线程被设置了中断标识，则当期线程中断自己。
         */
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
            AbstractQueuedSynchronizer.selfInterrupt();
        }
    }

    /**
     * 公平锁的同步对象
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        /**
         * 公平锁的获取操作
         */
        @Override
        @ReservedStackAccess
        protected boolean tryAcquire(int acquires) {
            // 读取当前线程
            final Thread current = Thread.currentThread();
            // 读取同步状态
            final int c = getState();
            // 1）同步状态为 0
            if (c == 0) {
                /**
                 * 1）同步队列中没有等待获取锁的线程或等待线程就是当前线程，
                 * 则比较更新同步状态。
                 */
                if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
                    // 更新成功则表示获取锁成功，返回 true
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 2）当前线程是持有锁的线程，锁重入
            else if (current == getExclusiveOwnerThread()) {
                // 递增同步状态值
                final int nextc = c + acquires;
                if (nextc < 0) {
                    throw new Error("Maximum lock count exceeded");
                }
                // 更新同步状态值，获取成功返回 true
                setState(nextc);
                return true;
            }
            return false;
        }
    }

AbstractQueuedSynchronizer#hasQueuedPredecessors
    /**
     * 是否有线程在等待获取锁
     */
    public final boolean hasQueuedPredecessors() {
        // 读取尾节点
        final Node t = tail; // Read fields in reverse initialization order
        // 读取头节点
        final Node h = head;
        Node s;
        /**
         * 同步队列中存在等待节点，并且
         * 1）head.next==null，同步队列初始化时，说明已经有节点正在加入到同步队列中
         * 2）第一个等待获取锁的节点驻留线程不是当前线程【如果是当前线程，则可以重入】
         */
        return h != t &&
                ((s = h.next) == null || s.thread != Thread.currentThread());
    }

释放锁【公平锁和非公平锁一致】

    /**
     * 尝试释放锁
     */
    @Override
    public void unlock() {
        sync.release(1);
    }

AbstractQueuedSynchronizer#release
    /**
     * 在独占模式下释放锁
     */
    public final boolean release(int arg) {
        // 尝试释放锁
        if (tryRelease(arg)) {
            // 读取头节点
            final Node h = head;
            // 头结点的同步状态不为 0，则唤醒其后置节点
            if (h != null && h.waitStatus != 0) {
                // 唤醒目标节点的后继节点
                unparkSuccessor(h);
            }
            return true;
        }
        return false;
    }

Sync#tryRelease
        @Override
        @ReservedStackAccess
        protected final boolean tryRelease(int releases) {
            // 计算新的同步状态值
            final int c = getState() - releases;
            // 当前线程不是持有锁的线程
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                // 抛出 IllegalMonitorStateException 异常
                throw new IllegalMonitorStateException();
            }
            boolean free = false;
            // 同步状态值为 0，标识锁已经没有被线程持有
            if (c == 0) {
                free = true;
                // 清空锁持有线程
                setExclusiveOwnerThread(null);
            }
            // 更新状态值
            setState(c);
            return free;
        }

可中断地获取锁

    /**
     * 可响应中断地获取锁，一旦目标线程被其他中断，则抛出 InterruptedException 异常。
     */
    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

AbstractQueuedSynchronizer#acquireInterruptibly
    /**
     * 1）在独占模式下获取锁
     * 2）首先尝试进行一次锁获取，如果获取成功则直接返回；
     * 如果获取失败，则将当前线程加入同步队列中阻塞等待获取锁。
     * 3）如果目标线程被其他线程中断，则抛出 InterruptedException 异常
     */
    public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        // 返回并清除当前线程的中断标识，如果线程已经被中断
        if (Thread.interrupted()) {
            // 直接抛出 InterruptedException 异常
            throw new InterruptedException();
        }
        // 尝试获取锁
        if (!tryAcquire(arg)) {
            // 获取失败，则可中断地再次获取锁
            doAcquireInterruptibly(arg);
        }
    }

AbstractQueuedSynchronizer#doAcquireInterruptibly
    /**
     * 在独占模式下获取锁，可响应线程中断
     */
    private void doAcquireInterruptibly(int arg)
            throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        try {
            for (;;) {
                // 读取当前节点的前置节点
                final Node p = node.predecessor();
                // 如果前置节点是 head，则尝试获取锁
                if (p == head && tryAcquire(arg)) {
                    // 获取成功，则设置当前节点为 head
                    setHead(node);
                    p.next = null; // help GC
                    return;
                }
                // 当前线程是否需要被阻塞，如果需要，则阻塞当前线程，并等待唤醒，唤醒后返回其中断状态
                if (AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt()) {
                    // 如果当前线程被其他线程中断
                    throw new InterruptedException();
                }
            }
        } catch (final Throwable t) {
            // 取消正在获取的锁操作
            cancelAcquire(node);
            throw t;
        }
    }

尝试获取锁

    /**
     * 尝试进行一次获取锁操作
     */
    @Override
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

带超时时间的锁获取

    /**
     * 在指定的时间内，尝试获取锁，一旦超时，则直接返回结果。
     * 可响应线程中断。
     */
    @Override
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        // 将目标时间转换为纳秒
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

AbstractQueuedSynchronizer#tryAcquireNanos
    /**
     * 在独占模式下尝试获取锁，
     * 1）线程被中断，则直接抛出 InterruptedException 异常
     * 2）超出目标时间，则直接返回
     */
    public final boolean tryAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        // 获取并清除当前线程的中断标识
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
        /**
         *  1）尝试进行锁获取，成功则直接返回 true。
         *  2）获取失败，则基于指定的超时时间再次尝试获取锁，直到超时为止。
         */
        return tryAcquire(arg) ||
                doAcquireNanos(arg, nanosTimeout);
    }

AbstractQueuedSynchronizer#doAcquireNanos
    /**
     * 在独占、超时模式下获取锁
     */
    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);
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return true;
                }
                // 计算剩余时间
                nanosTimeout = deadline - System.nanoTime();
                // 已经超时
                if (nanosTimeout <= 0L) {
                    // 取消当前线程的锁获取操作
                    cancelAcquire(node);
                    return false;
                }
                /**
                 * 当前线程是否需要被阻塞，
                 * 1）如果超时时间大于 1000 纳秒，则阻塞当前线程。
                 * 2）否则进行自旋获取锁操作。
                 */
                if (AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire(p, node) &&
                        nanosTimeout > AbstractQueuedSynchronizer.SPIN_FOR_TIMEOUT_THRESHOLD) {
                    // 最多阻塞当前线程 nanosTimeout 纳秒
                    LockSupport.parkNanos(this, nanosTimeout);
                }
                // 当前线程是否被中断
                if (Thread.interrupted()) {
                    throw new InterruptedException();
                }
            }
        } catch (final Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }

    /**
     * 在许可可用之前阻塞当前线程。
     * 如果许可可用，则使用该许可，并且该调用立即返回；否则，当前线程将被阻塞。
     * 以下场景下该方法调用才会返回：
     * 1）其他某个线程将当前线程作为目标调用 unpark。
     * 2）其他某个线程中断当前线程。
     * 3）线程阻塞已经超出 nanos 纳秒
     * 4）该调用不合逻辑地（即毫无理由地）返回。
     */
    public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) {
            final Thread t = Thread.currentThread();
            LockSupport.setBlocker(t, blocker);
            LockSupport.U.park(false, nanos);
            LockSupport.setBlocker(t, null);
        }
    }

状态查询操作，基于队列的状态查询是不精确的

    /**
     * 当前可重入互斥锁是不是公平锁
     */
    public final boolean isFair() {
        return sync instanceof FairSync;
    }

    /**
     * 锁是不是被当前线程持有
     */
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }

    /**
     * 锁是不是已经被占用，同步状态不为 0
     */
    public boolean isLocked() {
        return sync.isLocked();
    }

    /**
     * 当前线程持有同步状态的计数值
     */
    public int getHoldCount() {
        return sync.getHoldCount();
    }