Java并发编程J.U.C之锁的获取与释放

上一篇文章中，我们对J.U.C的一些大概的情况做了了解，在这一篇文章我们将来以ReentrantLock为例，来分析一下锁的获取和释放的过程，让大家能够对锁的获取和释放的整体过程有一个了解。

一、锁的获取

先看下ReentrantLock的lock()方法，整个方法只有一行，调用acquire方法，看看acquire方法的实现：

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

再看看tryAcquire的实现：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (isFirst(current) &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

如果大于0，则判断当前线程是否是排他锁的持有线程，如果是，那么把state值加1（注意state是int类型的，所以state的最大值是就是int的最大值）

如果第一次tryAcquire()操作失败，那么就把当前线程加入到等待队列中去，看addWaiter()方法：

private Node addWaiter(Node mode) {
    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;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

最后在当前线程被加入到等待队列中去以后，再调用acquireQueued去获取锁，看看acquireQueued的代码：

final boolean acquireQueued(final Node node, int arg) {
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } catch (RuntimeException ex) {
        cancelAcquire(node);
        throw ex;
    }
}

整个锁的获取过程就是这样，我们再来总结一下整个过程：acquire()方法会先调用一次tryAcquire方法获取一次锁，如果失败，则把当前线程加入到等待队列中去，然后再调用acquireQueued获取锁，acquireQueued在当前节点不在头部的时候会把当前线程的前一个结点的状态置为SIGNAL，然后阻塞当前线程。当当前线程到了队列的头部的时候，那么获取锁的操作就会成功返回。

二、锁的释放

首先，我们知道在acquireQueued方法中，如果一个线程成功获取到了锁，那么它就应该是整个等待队列的head节点，然后，我们再来看一看unlock()方法，和lock()方法一样，unlock()方法也是只有一行代码，直接调用release()方法，我们看看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;
}

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

然后再看看唤醒继任节点的代码：

private void unparkSuccessor(Node node) {
    compareAndSetWaitStatus(node, Node.SIGNAL, 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;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

这段代码先清除当前节点的waitStatus为0，然后判断下一个节点是不是null或者cancelled的状态，如果是，则从队列的尾部往前开始找，找到一个非cancelled状态的节点，最后唤醒这个节点。

最后，总结一下释放操作的整个过程：其实整个释放过程就做了两件事情，一个是将state值减1，然后就是判断锁是否被完全释放，如果被完全释放，则唤醒继任节点。

三、整体过程描述

看了上面的锁的获取与释放操作以后，整体过程还是比较清晰的，在文章的最后，我们把获取与释放操作串在一起在简单看一下：

• 获取锁的时候将当前线程放入同步队列，并且将前一个节点的状态置为signal状态，然后阻塞
• 当这个节点的前一个节点成功获取到锁，前一个节点就成了整个同步队列的head。
• 当前一个节点释放锁的时候，它就唤醒当前线程的这个节点，然后当前线程的节点就可以成功获取到锁了
• 这个时候它就到整个队列的头部了，然后release操作的时候又可以唤醒下一个。