java独占锁的获取与释放详解

一.独占锁的获取

lock()方法是获取独占锁，获取失败就将当前线程加入同步队列，成功则线程执行。来看ReentrantLock源码:

final void lock() {
            if (this.compareAndSetState(0, 1)) {
                this.setExclusiveOwnerThread(Thread.currentThread());
            } else {
                this.acquire(1);
            }
        }

首先通过CAS尝试获取同步状态，成功则将持有锁的现场置为当前线程，获取锁失败则调用AQS提供的acquire(int arg)模板方法

public final void acquire(int arg) {
    // 再次尝试获取同步状态，如果成功则方法直接返回
    // 如果失败则先调用addWaiter()方法再调用acquireQueued()方法
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

acquire方法首先调用tryAcquire方法，tryAcquire方法会再次使用CAS尝试获取同步状态，若成功方法直接返回，当前线程置为持有锁的线程。若再次尝试失败，就会将当前线程加入同步队列，那么加入队列的方式是怎样的了？我们接下来就应该去研究一下addWaiter()和acquireQueued()。

addWaiter源码

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;
        //若尾节点不为空
        if (pred != null) {
            node.prev = pred;
            //将当前结点使用CAS尾插入同步队列
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                // CAS尾插成功，返回当前Node节点
                return node;
            }
        }
        // 尾节点为空 || CAS尾插失败
        enq(node);
        return node;
    }

1. 当前同步队列的尾节点为null，调用方法enq()插入;

2. 当前队列的尾节点不为null，则采用尾插入（compareAndSetTail（）方法）的方式入队。

enq（） 方法作用是当同步队列为空时，完成同步队列初始化操作，以及不断CAS将当前结点尾插入同步队列

private Node enq(final Node node) {
        //死循环-不断自旋
        // 直到将当前节点插入同步队列成功为止
        for (;;) {
            //拿到尾结点
            Node t = tail;
            //当前队列为空
            if (t == null) { // Must initialize
                //完成队列初始化操作，lazy-load懒加载模式
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                //不断将当前结点使用CAS尾插入同步队列中直到成功为止
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

现在我们已经知道获取独占式锁失败的线程包装成Node然后插入同步队列的过程了。那么在同步队列中的节点（线程）应该怎么做才能保证自己能够有机会获得独占式锁了？我们看acquireQueued方法，这个方法的作用就是排队获取锁的过程

final boolean acquireQueued(final Node node, int arg) {
    //设置失败状态，初始化为true
    boolean failed = true;
    try {
        //设置中断状态，默认为false
        boolean interrupted = false;
        //不断自旋
        for (;;) {
            //拿到当前结点前驱结点
            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)
            //将当前结点置为取消状态，node.waitStutas = 1
            cancelAcquire(node);
    }
}

 

整体来看这是一个这又是一个自旋的过程（for (;;)），代码首先获取当前节点的先驱节点，如果先驱节点是头结点的并且成功获得同步状态的时候（if (p == head && tryAcquire(arg))），当前节点所指向的线程能够获取锁。反之，获取锁失败进入等待状态。整体示意图为下图：

结点从同步队列获取同步状态的前提条件：if (p == head && tryAcquire(arg))，只有当前驱结点为头节点时，线程才有机会获取同步状态。

获取锁的节点出队的逻辑是：

//队列头结点引用指向当前节点
setHead(node);
//释放前驱节点
p.next = null; // help GC
failed = false;
return interrupted

将当前节点通过setHead()方法设置为队列的头结点，然后将之前的头结点的next域设置为null并且pre域也为null，即与队列断开，无任何引用方便GC时能够将内存进行回收。示意图

当前线程获取同步状态失败时，先调用shouldParkAfterFailedAcquire(Node pred, Node node)

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //获取前驱结点状态
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
         //表示应将当前结点阻塞
        return true;
    //前驱结点被取消    
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
         //一直向前找到结点状态不是取消状态的结点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
         //将前驱结点状态置为signal （-1）
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

shouldParkAfterFailedAcquire()方法主要逻辑是使用 使用CAS将节点状态由INITIAL设置成SIGNAL，表示当前线程阻塞。当 compareAndSetWaitStatus 设置失败则说明shouldParkAfterFailedAcquire方法返回false，然后会在acquireQueued()方法中for (;;)死循环中会继续重试，直至compareAndSetWaitStatus设置节点状态位为SIGNAL时shouldParkAfterFailedAcquire返回true时才会执行方法parkAndCheckInterrupt()方法，该方法的源码为：

private final boolean parkAndCheckInterrupt() {
       LockSupport.park(this);
    return Thread.interrupted();
}

该方法的关键是会调用LookSupport.park()方法，该方法是用来阻塞当前线程的。

通过上面的流程我们可以了解到acquireQueued()在自旋过程中主要完成了两件事情：

1. 如果当前节点的前驱节点是头节点，并且能够获得同步状态的话，当前线程能够获得锁该方法执行结束退出；

2. 获取锁失败的话，先将节点状态设置成SIGNAL，然后调用LookSupport.park方法使得当前线程阻塞。

acquire方法的执行流程

二.独占锁的释放 

独占锁的释放调用unlock方法，而该方法实际调用了AQS的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返回true）则会执行if块中的代码，当head指向的头结点不为null，并且该节点的状态值不为0的话才会执行unparkSuccessor()方法。

private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, 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;
    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;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

unparkSuccessor方法找到距离头节点最近的一个非空结点并调用LockSupport.unpark方法唤醒（为什么要找距离头节点最近的结点呢？——是为了保证公平性，因为距离头结点最近的结点一定存放的是等待时间最长的线程）

总结

1. 线程获取锁失败，线程被封装成Node进行入队操作，核心方法在于addWaiter()和enq()，同时enq()完成对同步队列的头结点初始化工作以及CAS操作失败的重试;
2. 线程获取锁是一个自旋的过程，当且仅当当前节点的前驱节点是头结点并且成功获得同步状态时，节点出队即该节点引用的线程获得锁，否则，当不满足条件时就会调用LookSupport.park()方法使得线程阻塞；
3. 释放锁的时候会唤醒后继节点；
总体来说：在获取同步状态时，AQS维护一个同步队列，获取同步状态失败的线程会加入到队列中进行自旋；移出队列（或停止自旋）的条件是前驱节点是头结点并且成功获得了同步状态。在释放同步状态时，同步器会调用unparkSuccessor()方法唤醒后继节点。