Volatile with synchronized together

Question

Is there any reason to use volatile and synchronized together in this code?

public class Helper {
  private volatile int n;
  private final Object lock = new Object();
  public Helper(int n) {
    this.n = n;
  }

  public void setN(int value) {
    synchronized (lock) {
      n = value;
    }
  }
}

Class Helper must be thread safe. I've got this example from the "Java Concurrency Guidelines" book, but it is still not clear: what is the reason for using volatile and synchronized together in this example?

Answer 1

The purpose of this example is to point out that syncronized without volatile isn't enough in this case given the fact that object can be published unsafely (i.e. without volatile in Foo):

If the helper field in the Foo class is not declared volatile, the n field should be declared volatile so that a happens-before relationship is established between the initialization of n and the write of Helper to the helper field. This is in compliance with guideline “VNA06-J. Do not assume that declaring an object reference volatile guarantees visibility of its members” on page 35. This is required only when the caller (class Foo) cannot be trusted to declare helper volatile.

That's correct, but they chose a bad example to demonstrate it, because volatile without syncrhonization is enough in this case.

Answer 2

It's not necessary to put the synchronised block around the change in value; since Java 5 this is done "automatically" for volatile variables. I think that previous to Java 5, it was not necessarily the case.