一、基本使用方法

ReentrantLock reentrantLock = new ReentrantLock();

reentrantLock.lock();

reentrantLock.unlock();

二、查看方法实现

（1）实例化

public ReentrantLock() {
    sync = new NonfairSync();
}

（2）lock方法

public void lock() {
    sync.lock();
}

（3）unlock方法

public void unlock() {
    sync.release(1);
}

都是调用了NonfairSync对象中的方法，那我们查看一下这个NonfairSync是什么

三、NonfairSync

继承关系

NonfairSync => Sync => AbstractQueuedSynchronizer => AbstractOwnableSynchronizer

（1）AbstractOwnableSynchronizer

关键是持有一个Thread 变量，表示一个锁必须要记录当前拥有的线程是什么。

private transient Thread exclusiveOwnerThread;

（2）AbstractQueuedSynchronizer

关键是持有head，tail，state。主要作用是维护一个同步的线程等待队列和锁记录标识。线程等待队列的实现依靠head、tail节点和CAS方法。锁依靠state字段和CAS方法。

    private transient volatile Node head;

    private transient volatile Node tail;

    private volatile int state;

（3）Sync和NonfairSync

利用AbstractQueuedSynchronizer中封装的方法，实现锁的逻辑。

四、锁的使用流程分析

（1）lock方法

作用：尝试加锁，加锁成功则标记当前线程、加锁失败则将当前线程挂起，线程入队，等待唤醒。

final void lock() {
    //获取锁成功，则记录锁持有的线程为当前线程
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        //获取锁失败，则需要将当前线程挂起，并放入到队列中
        acquire(1);
}

compareAndSetState方法，利用unsafe中的CAS修改state状态，即锁的状态。锁获取成功返回true，失败返回false。

protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

setExclusiveOwnerThread方法，记录当前持有锁的线程。

protected final void setExclusiveOwnerThread(Thread thread) {
    exclusiveOwnerThread = thread;
}

关键点在于acquire方法，最终目的是挂起当前线程，放入队列，并在被唤醒之后重新抢锁。

public final void acquire(int arg) {
    //再次抢锁
    //如果抢锁成功，则不进行acquireQueued方法（也就是不需要挂起和入队）
    //如果抢锁失败，则进行acquireQueued方法，（目的是挂起当前线程，放入队列）
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

tryAcquire方法最终会走到的方法是nonfairTryAcquire，抢锁的具体实现，成功返回true，失败返回false。

final boolean nonfairTryAcquire(int acquires) {
    //拿到当前线程
    final Thread current = Thread.currentThread();
    //获取state字段的状态
    int c = getState();
    //c为0时，才能去抢锁
    if (c == 0) {
        //抢锁成功 返回true
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //如果是持有锁的线程是当前线程
    else if (current == getExclusiveOwnerThread()) {
        //计数+1之后，设置state，返回true
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    //抢锁失败
    return false;
}

addWaiter方法，将当前线程包装成Node节点，并且通过死循环和CAS完成同步的入队操作。acquireQueued主要是在入队操作之后，阻塞当前的线程。

    private Node addWaiter(Node mode) {
        //先将当前的线程构建成一个node对象
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;

        //如果tail节点不为null，就尝试把当前线程构造的node节点加入到tail后面
        if (pred != null) {
            node.prev = pred;
            //尝试将新建的node加入到队尾，如果失败的话，可能有多种结果，所以后面的enq会死循环的去处理
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }

        //如果tail节点为null，或者上一步尝试加入尾节点失败，那就调用enq方法
        enq(node);
        return node;
    }

enq方法。作用：死循环的将当前线程入队，同步入队的关键方法。

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        //如果tail为null，表示还没有初始化head和tail，设置head节点和头节点
        if (t == null) { // Must initialize（初始化操作）
            //创建一个新的node，赋值给head
            if (compareAndSetHead(new Node()))
                //赋值完给head之后，让tail和head指向同一个新的node
                tail = head;
        } else {
            node.prev = t;
            //将tail设置为当前的node
            if (compareAndSetTail(t, node)) {
                //将上次的tail的next修改为当前的node
                t.next = node;
                
                //这个地方才会结束循环，返回的是当前线程node
                return t;
            }
        }
    }
}

acquireQueued方法作用：阻塞当前线程，并在被唤醒之后重新抢锁。

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            //获取node的前置节点
            final Node p = node.predecessor();
            //如果是队头，则进行抢锁操作
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //不是队列的线程，或者抢锁失败的线程（这种线程需要挂起等待唤醒）
            if (shouldParkAfterFailedAcquire(p, node) &&
                //挂起当前线程
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

（2）unlock方法

作用：解锁，唤醒下一个线程。

  public void unlock() {
        sync.release(1);
    }

release方法。具体解锁的实现。

public final boolean release(int arg) {
    //如果解锁成功
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            //释放成功的话，需要去唤醒线程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

tryRelease方法。作用：尝试释放独占锁。

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    //如果当前线程不是持有锁的线程，表示存在问题。
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    //0的情况下才会完全释放锁
    if (c == 0) {
        free = true;
        //设置锁的持有线程为null
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

unparkSuccessor方法。作用：唤醒队列中下一个线程。

private void unparkSuccessor(Node node) {
  
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    //目的就是为了调用unpak方法唤醒线程
    if (s != null)
        LockSupport.unpark(s.thread);
}

ReentrantLock源码分析