为什么 AbstractOwnableSynchronizer.exclusiveOwnerThread 未声明为 volatile？

Question

在阅读java.util.concurrent.locks.ReentrantLock的源码时发现tryLock()方法的实现如下：

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

根据AbstractQueuedSynchronizer 中维护的state，我们尝试“拥有”锁或检查我们是否已经拥有锁。但我想知道为什么变量 state 被声明为 volatile 而变量 exclusiveOwnerThread 不是？

Answer 1

要了解为什么exclusiveOwnerThread 不需要是易失性的，将获取和释放方法一起查看会有所帮助。

获取方法¹：

/**
 * Performs non-fair tryLock.  tryAcquire is implemented in
 * subclasses, but both need nonfair try for trylock method.
 */
@ReservedStackAccess
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

发布方式：

@ReservedStackAccess
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;
}

同样重要的是要意识到exclusiveOwnerThread 不会引用与所涉及的线程无关的任意对象。它专门持有对Thread 实例的引用，并严格与调用线程进行比较。换句话说，重要的是：

Thread.currentThread() == getExclusiveOwnerThread()

由于#nonfairTryAcquire(int) 和#tryRelease(int) 的组合性质，当且仅当调用线程先前调用了#setExclusiveOwnerThread(Thread)，并且将其自身作为参数时，这将是正确的。一个线程中的操作总是发生在同一线程中的后续操作。

所以如果c != 0那么有两种情况：

1. 调用线程拥有同步器。

   • 由于一个线程中的操作总是发生在同一线程中的后续操作，因此保证getExclusiveOwnerThread() 将返回对调用线程的引用。

2. 调用线程不拥有同步器。

   • getExclusiveOwnerThread() 返回的引用不再重要，因为该方法不可能返回对调用线程的引用。

     由于#tryRelease(int) 中的setExclusiveOwnerThread(null) 调用，调用线程永远不会看到对自身的过时引用。这意味着getExclusiveOwnerThread() 可以返回null 或其他一些Thread 引用（无论是否过期），但绝不是对调用线程的引用。

state 必须是 volatile 的原因是因为它在线程之间以一种最重要的方式共享，每个线程都能看到最新的值。

---

^{1. FairSync#tryAcquire(int) 的实现几乎相同，只是它考虑了调用线程的顺序。}