Question

Given the following code:

public class FooBar { 

  public static volatile ConcurrentHashMap myConfigData  = new ConcurrentHashMap();      

}

public class UpdaterThread implements Runnable { 

  public void run() {
    //Query the Data from the DB and Update the FooBar config Data
    FooBar.myConfigData = ConfigDataDAO.getLatestConfigFromDB();
  }

}

The Thread-Class will update the myConfigData Membervariable regularly (via an Executor every 5 minutes). Is the setting of of myConfigData in the “external” Thread threadsafe (atomic), or do I have to synchronize every Read and Write operation to the myConfigData Variable?

EDIT: The question is not whether ConcurrentHashMap is threadsafe (it is according to javadoc) but rather the setting of the ConcurrentHashMap itself in the myConfigData Member variable. This variable might be read and written “at once” by several threads so the question is whether the setting is atomic or not. I think this can be generalized to “Is the setting of a Java reference variable atomic or not?”.

(I also made it volatile. This is a different issue and has nothing to do with atomicity – my question – but rather “visibility in other threads” and the happens-before relationship.)

Answer 1

Replacing references is safe. See Java language Specification:

When a thread uses the value of a variable, the value it obtains is in fact a value stored into the variable by that thread or by some other thread. This is true even if the program does not contain code for proper synchronization. For example, if two threads store references to different objects into the same reference value, the variable will subsequently contain a reference to one object or the other, not a reference to some other object or a corrupted reference value. (There is a special exception for long and double values; see §17.4.)