Safe publication when values are read in synchronized methods.

Question

My question concerns safe publication of field values in Java (as discuessed here http://stackoverflow.com/questions/801993/java-multi-threading-safe-publication).

As I understand it, a field can be safely read (meaning access from multiple threads will see the correct value) if:

• read and write are synchronized on the same monitor
• field is final
• field is volatile

If my understanding is correct the following class should not be thread-safe since the initial value is written without these characteristics. However I find it hard to believe that I need to make first volatile even though it is only accessed from a synchronized method.

public class Foo {

    private boolean needsGreeting = true;

    public synchronized void greet() {
        if (needsGreeting) {
            System.out.println("hello");
            needsGreeting = false;
        }
    }
}

Am I missing something? Is above code correct and if so why? Or is it necessary in such cases to make first volatile or use a final AtomicBoolean or something like that in addition to accessing it from a synchronized method.

(Just to clarify, I am aware, that if the initial value was written in a synchronized method, it would be thread-safe even without the volatile keyword.)

Answer 1

Strictly speaking, I can't see that it is safe to assume, that needsGreeting is set to true, when greet is called.

For this to be true, there would have to be a happens before relation between the initial write (occurring when the object is constructed) and the first read (in the greet-method). Chapter 17 in the JLS however, states the following about happens-before (hb) constraints:

17.4.5 Happens-before Order Two actions can be ordered by a happens-before relationship. If one action happens-before another, then the first is visible to and ordered before the second.

If we have two actions x and y, we write hb(x, y) to indicate that x happens-before y.

• If x and y are actions of the same thread and x comes before y in program order, then hb(x, y).
• There is a happens-before edge from the end of a constructor of an object to the start of a finalizer (§12.6) for that object.
• If an action x synchronizes-with a following action y, then we also have hb(x, y).
• If hb(x, y) and hb(y, z), then hb(x, z).

Furthermore, the only way to introduce a synchronized-with relation, that is, a synchronization order is to do something of the following:

Synchronization actions induce the synchronized-with relation on actions, defined as follows:

• An unlock action on monitor m synchronizes-with all subsequent lock actions on m (where subsequent is defined according to the synchronization order).
• A write to a volatile variable (§8.3.1.4) v synchronizes-with all subsequent reads of v by any thread (where subsequent is defined according to the synchronization order).
• An action that starts a thread synchronizes-with the first action in the thread it starts.
• The write of the default value (zero, false or null) to each variable synchronizes-with the first action in every thread. Although it may seem a little strange to write a default value to a variable before the object containing the variable is allocated, conceptually every object is created at the start of the program with its default initialized values.
• The final action in a thread T1 synchronizes-with any action in another thread T2 that detects that T1 has terminated. T2 may accomplish this by calling T1.isAlive() or T1.join().
• If thread T1 interrupts thread T2, the interrupt by T1 synchronizes-with any point where any other thread (including T2) determines that T2 has been interrupted (by having an InterruptedException thrown or by invoking Thread.interrupted or Thread.isInterrupted).

It says nowhere that "the construction of an object happens before any calls to methods on the object. The happens-before relation however, states that there is a happens-before edge from the end of a constructor of an object to the start of a finalizer (§12.6) for that object., which may be a hint about that there is not an happens-before edge from the end of a constructor of an object to the start of an arbitrary method!

Answer 2

There is no happens-before relationship between the end of a constructor and method invocations, and as such it is possible for one thread to start constructing the instance and make the reference available and for another thread to acquire that reference and start calling the greet() method on a partially constructed object. The synchronization in greet() does not really address that issue.

If you publish an instance via the celebrated double-checked locking pattern, it becomes easier to see how. If there was such a happens-before relationship, it should have been safe even if DCLP is used.

public class Foo {
    private boolean needsGreeting = true;

    public synchronized void greet() {
        if (needsGreeting) {
            System.out.println("Hello.");
            needsGreeting = false;
        }
    }
}

class FooUser {
    private static Foo foo;

    public static Foo getFoo() {
        if (foo == null) {
            synchronized (FooUser.class) {
                if (foo == null) {
                    foo = new Foo();
                }
            }
        }
        return foo;
    }
}

If multiple threads call FooUser.getFoo().greet() at the same time, one thread might be constructing the Foo instance, but another thread may find a non-null Foo reference prematurely, and call greet() and find needsGreeting is still false.

An example of this is mentioned in Java Concurrency in Practice (3.5).