我有一个映射，这是由几个线程并发修改。
在Java API中似乎有三种不同的同步Map实现:
哈希表 collections . synchronizedmap(地图) ConcurrentHashMap
根据我的理解，Hashtable是一个旧的实现(扩展了过时的Dictionary类)，后来为了适应Map接口而进行了调整。虽然它是同步的，但它似乎有严重的可伸缩性问题，不推荐用于新项目。
那另外两个呢?Collections.synchronizedMap(Map)和ConcurrentHashMaps返回的Map之间有什么区别?哪一种适合哪种情况?
当前回答
╔═══════════════╦═══════════════════╦═══════════════════╦═════════════════════╗
║ 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只锁定桶。
其他回答
你对哈希表的看法是对的，你可以忘了它。
你的文章提到，虽然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将只锁定正在更新的部分数据，而其他部分数据可以由其他线程访问。但是，Collections.synchronizedMap()将在更新时锁定所有数据，其他线程只能在释放锁时访问数据。如果更新操作较多，读操作相对较少，则选择ConcurrentHashMap。
Also one other difference is that ConcurrentHashMap will not preserve the order of elements in the Map passed in. It is similar to HashMap when storing data. There is no guarantee that the element order is preserved. While Collections.synchronizedMap() will preserve the elements order of the Map passed in. For example, if you pass a TreeMap to ConcurrentHashMap, the elements order in the ConcurrentHashMap may not be the same as the order in the TreeMap, but Collections.synchronizedMap() will preserve the order.
此外，ConcurrentHashMap可以保证当一个线程更新映射而另一个线程遍历从映射中获得的迭代器时，不会抛出ConcurrentModificationException。但是，Collections.synchronizedMap()在此上不被保证。
有一篇文章展示了这两者的区别，还有ConcurrentSkipListMap。
如果数据一致性非常重要-使用Hashtable或Collections.synchronizedMap(Map)。 如果速度/性能非常重要，数据更新可能会受到影响-使用ConcurrentHashMap。
根据您的需要，使用ConcurrentHashMap。它允许从多个线程并发修改Map，而不需要阻塞它们。synchronizedmap (map)创建了一个阻塞map，这会降低性能，但确保了一致性(如果使用得当)。
如果您需要确保数据的一致性，并且每个线程需要有一个最新的映射视图，则使用第二个选项。如果性能非常关键，并且每个线程只向映射中插入数据，读取频率较低，则使用第一种方法。
