Is volatile needed, in case of only synchronized access [duplicate]

Question

Shall the emitting variable be volatile? the emit() method is called from different threads, and emit must be visible.
But it is accessed in synchronized blocks only. The // ... are places where the work is done, but emitting is not referenced here.

So, if the structure of synchronized is fix, do I still need a volatile for emitting or not? (and why?)

static final class C {
    boolean emitting = false; // shall be volatile ?

    public void emit() {
        synchronized (this) {
            if (emitting) {
                return;
            }
            // ...
            emitting = true;
        }

        // ...

        synchronized (this) {
            if (!condition()) {
                emitting = false;
                return;
            }
        }
        // ...
    }

Frank

Answer 1

If it is accessed only from synchronized blocks is not needed the volatile keyword.

Synchronized guarantees that changes to variables accessed inside the synchronized block are visible to all threads entering a synchronized block.

From the book Java concurrency in practice:

To publish an object safely, both the reference to the object and the object's state must be made visible to other threads at the same time. A properly constructed object can be safely published by:

• Initializing an object reference from a static initializer;
• Storing a reference to it into a volatile field or Atomic Reference ;
• Storing a reference to it into a final field of a properly constructed object;
• Storing a reference to it into a field that is properly guarded by a lock.

Note: guarded by a lock means entered in a synchronized block