你对哈希表的看法是对的，你可以忘了它。

你的文章提到，虽然HashTable和同步包装器类通过一次只允许一个线程访问映射来提供基本的线程安全，但这并不是“真正的”线程安全，因为许多复合操作仍然需要额外的同步，例如:

synchronized (records) {
  Record rec = records.get(id);
  if (rec == null) {
      rec = new Record(id);
      records.put(id, rec);
  }
  return rec;
}

但是，不要认为ConcurrentHashMap是具有典型同步块的HashMap的简单替代方案。阅读这篇文章可以更好地理解其复杂性。

╔═══════════════╦═══════════════════╦═══════════════════╦═════════════════════╗
║   Property    ║     HashMap       ║    Hashtable      ║  ConcurrentHashMap  ║
╠═══════════════╬═══════════════════╬═══════════════════╩═════════════════════╣ 
║      Null     ║     allowed       ║              not allowed                ║
║  values/keys  ║                   ║                                         ║
╠═══════════════╬═══════════════════╬═════════════════════════════════════════╣
║ Thread-safety ║                   ║                                         ║
║   features    ║       no          ║                  yes                    ║
╠═══════════════╬═══════════════════╬═══════════════════╦═════════════════════╣
║     Lock      ║       not         ║ locks the whole   ║ locks the portion   ║        
║  mechanism    ║    applicable     ║       map         ║                     ║ 
╠═══════════════╬═══════════════════╩═══════════════════╬═════════════════════╣
║   Iterator    ║               fail-fast               ║ weakly consistent   ║ 
╚═══════════════╩═══════════════════════════════════════╩═════════════════════╝

关于锁定机构: Hashtable锁定对象，而ConcurrentHashMap只锁定桶。

除了ConcurrentHashMap提供的并发特性之外，还有一个重要的特性需要注意，那就是故障安全迭代器。我见过开发人员使用ConcurrentHashMap只是因为他们想编辑条目集——在迭代时放置/删除它。 synchronizedmap (Map)不提供故障安全迭代器，但它提供了快速故障迭代器。快速失败迭代器使用映射大小的快照，在迭代过程中不能编辑。

ConcurrentHashMap

ConcurrentHashMap for performance-critical applications where there are far more write operations than there are read operations. It is thread safe without synchronizing the whole map. Reads can happen very fast while write is done with a lock. There is no locking at the object level. The locking is at a much finer granularity at a hashmap bucket level. ConcurrentHashMap doesn’t throw a ConcurrentModificationException if one thread tries to modify it while another is iterating over it. ConcurrentHashMap uses multitude of locks. read operations are non-blocking, whereas write operations take a lock on a particular segment or bucket.

SynchronizedHashMap

对象级同步。 每个读/写操作都需要获得锁。 锁定整个集合是一种性能开销。 这实际上只允许一个线程访问整个映射，并阻塞了所有其他线程。 这可能会引起争论。 SynchronizedHashMap返回迭代器，它在并发修改时快速失败。

Collection.synchronizedMap ()

Collections实用程序类提供了操作集合并返回包装集合的多态算法。它的synchronizedMap()方法提供了线程安全的功能。 当数据一致性至关重要时，我们需要使用Collections.synchronizedMap()。

源

ConcurrentHashMap在Java 1.5中作为哈希表的替代品，作为并发包的一部分。使用ConcurrentHashMap，不仅可以安全地在并发多线程环境中使用，而且提供了比Hashtable和synchronizedMap更好的性能，那么您就有了更好的选择。ConcurrentHashMap性能更好，因为它锁定了Map的一部分。它允许并发读操作，同时通过同步写操作来保持完整性。

ConcurrentHashMap是如何实现的

ConcurrentHashMap was developed as alternative of Hashtable and support all functionality of Hashtable with additional ability, so called concurrency level. ConcurrentHashMap allows multiple readers to read simultaneously without using blocks. It becomes possible by separating Map to different parts and blocking only part of Map in updates. By default, concurrency level is 16, so Map is spitted to 16 parts and each part is managed by separated block. It means, that 16 threads can work with Map simultaneously, if they work with different parts of Map. It makes ConcurrentHashMap hight productive, and not to down thread-safety.

如果你对ConcurrentHashMap的一些重要特性感兴趣，以及什么时候应该使用这种Map的实现——我只是放了一个链接到一篇好文章——如何在Java中使用ConcurrentHashMap

如果可以使用ConcurrentHashMap，则首选它——尽管它至少需要Java 5。

它被设计成在多线程使用时可以很好地扩展。当一次只有一个线程访问Map时，性能可能会稍微差一些，但当多个线程并发访问映射时，性能会显著提高。

我找到了一篇博客文章，它复制了优秀的《Java并发实践》一书中的一个表格，我强烈推荐这本书。

集合。synchronizedMap只有在需要用其他特征(可能是某种有序映射，如TreeMap)来包装映射时才有意义。