带有 hashmap 的廉价读写锁

Question

 static volatile Map currentMap = null;   // this must be volatile
static Object lockbox = new Object();  
 
public static void buildNewMap() {       // this is called by the producer     
    Map newMap = new HashMap();          // when the data needs to be updated
 
    synchronized (lockbox) {                 // this must be synchronized because
                                         // of the Java memory model
      // .. do stuff to put things in newMap
      newMap.put(....);
      newMap.put(....);
   }                 
/* After the above synchronization block, everything that is in the HashMap is 
   visible outside this thread */
 
/* Now make the updated set of values available to the consumer threads.  
   As long as this write operation can complete without being interrupted, 
   and is guaranteed to be written to shared memory, and the consumer can 
   live with the out of date information temporarily, this should work fine */
 
    currentMap = newMap;
 
}
public static Object getFromCurrentMap(Object key) {
    Map m = null;
    Object result = null;
 
    m = currentMap;               // no locking around this is required
    if (m != null) {              // should only be null during initialization
      Object result = m.get(key); // get on a HashMap is not synchronized
     
      // Do any additional processing needed using the result
    }
    return(result);
 
}

这是本文https://www.ibm.com/developerworks/library/j-hashmap/index.html的代码示例 我仍然不明白为什么我们需要在 buildNewMap 方法中使用同步块。除了 currentMap = newMap;做。 当我们在 m = currentMap; 处读取地图参考时；我们依赖 volatile 读写，读取线程甚至不知道生产者线程中的同步......

Answer 1

如果 hashmap 仅在写入 'currentMap' 之前被修改，则它的内容保证对其他线程可见。这是因为在写入地图内容和写入 currentMap（程序顺序）之间有一个发生在边缘之前；并且在读取concurrentMap之间有一个happens-before边缘（易失性变量），并且在读取变量和读取内容（程序顺序）之间有一个happens before edge。由于happens before是可传递的，因此在写入内容和读取内容之间存在一个happens beforge边缘。

同步块似乎没有任何用途。

Answer 2

根据这篇文章，Java 内存模型为易失性写入提供了强有力的保证：

http://tutorials.jenkov.com/java-concurrency/volatile.html

特别是：

• 如果线程 A 写入 volatile 变量，而线程 B 随后读取相同的 volatile 变量，则线程 A 在写入 volatile 变量之前可见的所有变量，在线程 B 读取 volatile 变量后也将可见。
• 如果线程 A 读取 volatile 变量，则线程 A 在读取 volatile 变量时可见的所有变量也将从主内存中重新读取。

所以看起来同步块是不必要的。