从使用角度看 ReentrantLock 和 Condition

java 语言中谈到锁，少不了比较一番 synchronized 和 ReentrantLock 的原理，本文不作分析，只是简单介绍一下 ReentrantLock 的用法，从使用中推测其内部的一些原理。

代码示例：

public static void main(String[] args) throws InterruptedException {
        final ReentrantLock lock = new ReentrantLock();
        final Condition con1 = lock.newCondition();
        final Condition con2 = lock.newCondition();
        
//        lock.lock();
        
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    con1.await();
                    System.out.println("wake from cond1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        t1.start();
        
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    con2.await();
                    System.out.println("wake from cond2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        t2.start();
        
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    con2.await();
                    System.out.println("wake from cond2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        t3.start();
        
        Thread.sleep(100);
        try {
            lock.lock();
            System.out.println("lock.getQueueLength() = " + lock.getQueueLength());
            System.out.println("lock.getWaitQueueLength(con1) = " + lock.getWaitQueueLength(con1));
            System.out.println("lock.getWaitQueueLength(con2) = " + lock.getWaitQueueLength(con2));
            con1.signal();
            con2.signalAll();
            
            Thread.sleep(100);
            System.out.println("lock.getWaitQueueLength(con1) = " + lock.getWaitQueueLength(con1));
            System.out.println("lock.getWaitQueueLength(con2) = " + lock.getWaitQueueLength(con2));
        } finally {
            lock.unlock();
        }

    }

以 ReentrantLock.getQueueLength 和 ReentrantLock.getWaitQueueLength 作为入口：前者作用是返回获取锁失败，处于等待状态的线程个数，后者是返回等待某一个 condition 的线程个数。

// int java.util.concurrent.locks.ReentrantLock.getQueueLength()
public final int getQueueLength() {
    return sync.getQueueLength();
}

// int java.util.concurrent.locks.AbstractQueuedSynchronizer.getQueueLength()
public final int getQueueLength() {
    int n = 0;
    for (Node p = tail; p != null; p = p.prev) {
        if (p.thread != null)
            ++n;
    }
    return n;
}

很简单，就是遍历阻塞线程的链表。

// int java.util.concurrent.locks.ReentrantLock.getWaitQueueLength(Condition condition)
public int getWaitQueueLength(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}

// int java.util.concurrent.locks.AbstractQueuedSynchronizer.getWaitQueueLength(ConditionObject condition)
public final int getWaitQueueLength(ConditionObject condition) {
    if (!owns(condition))
        throw new IllegalArgumentException("Not owner");
    return condition.getWaitQueueLength();
}

// int java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject.getWaitQueueLength()
protected final int getWaitQueueLength() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    int n = 0;
    for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
        if (w.waitStatus == Node.CONDITION)
            ++n;
    }
    return n;
}

同样，也是遍历链表，不同的是，这是 Condition 的链表。

现在，我们知道，ReentrantLock 中有 2 种不同的链表，其一是阻塞线程，其二是 Condition 等待链表，2 中链表都是使用 Node：

// java.util.concurrent.locks.AbstractQueuedSynchronizer.Node 
static final class Node {
    static final Node EXCLUSIVE = null;
    // 线程阻塞节点的状态
    static final int CANCELLED =  1;
    static final int SIGNAL    = -1;
    // condition 节点的状态
    static final int CONDITION = -2;
    static final int PROPAGATE = -3;
    volatile int waitStatus;
    volatile Node prev;
    volatile Node next;
    volatile Thread thread;
}

节点的类型表明链表的类型。

看看 Condition 实现类的 api：

public class ConditionObject implements Condition, java.io.Serializable {
    private static final long serialVersionUID = 1173984872572414699L;
    private transient Node firstWaiter;
    private transient Node lastWaiter;

    /**
     * Adds a new waiter to wait queue.
     * @return its new wait node
     */
    private Node addConditionWaiter() {
        Node t = lastWaiter;
        // If lastWaiter is cancelled, clean out.
        if (t != null && t.waitStatus != Node.CONDITION) {
            unlinkCancelledWaiters();
            t = lastWaiter;
        }
        Node node = new Node(Thread.currentThread(), Node.CONDITION);
        if (t == null)
            firstWaiter = node;
        else
            t.nextWaiter = node;
        lastWaiter = node;
        return node;
    }

    public final void await() throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        Node node = addConditionWaiter();
        int savedState = fullyRelease(node);
        int interruptMode = 0;
        while (!isOnSyncQueue(node)) {
            LockSupport.park(this);
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
        }
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        if (node.nextWaiter != null) // clean up if cancelled
            unlinkCancelledWaiters();
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
    }

    /**
     * Moves the longest-waiting thread, if one exists, from the
     * wait queue for this condition to the wait queue for the
     * owning lock.
     *
     * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
     *         returns {@code false}
     */
    public final void signal() {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
        if (first != null)
            doSignal(first);
    }
}

在开头的示例中，创建了 2 个 Condition 对象，每个Condition 对象有一个自己的等待链表。