java.io.FileInputStream accesses private volatile variable 'closed' only from inside synchronized block. Why?

Question

As far as I know, 'happens-before' states that changes made inside synchronized are visible to next thread, synchronizing on the same lock.

private final Object closeLock = new Object();
private volatile boolean closed = false;

public void close() throws IOException {
    synchronized (closeLock) {
        if (closed) {
            return;
        }
        closed = true;
    }
    if (channel != null) {
       channel.close();
    }

    fd.closeAll(new Closeable() {
        public void close() throws IOException {
           close0();
       }
    });
}

Isn't it redundant?

Answer 1

Synchronization makes two different guarantees in Java: visibility and atomicity. Making the variable volatile guarantees that the JVM will ensure visibility of writes properly follow "happens-before", but does not guarantee that the check-then-act within the synchronized block is atomic.

Without the guarantee of atomicity, thread interleaving on that sequence of if (closed) return; closed = true; could result in some synchronization issues.

If the variable is always accessed from within synchronized blocks on the same monitor, the volatile is not necessary, but might have some other minor performance impact.

Answer 2

The variable is likely accessed by the native methods. You'll need to look at the native source code for the JDK.

Answer 3

The volatile keyword is redundant, according to the second bullet point of Memory Consistency Properties.

An unlock (synchronized block or method exit) of a monitor happens-before every subsequent lock (synchronized block or method entry) of that same monitor. And because the happens-before relation is transitive, all actions of a thread prior to unlocking happen-before all actions subsequent to any thread locking that monitor.