提供ConcurrentHashMap线程安全但文档状态：

“然而，即使所有操作都是线程安全的，检索操作并不需要锁定”

因此，据我所知，获取或设置键和值是线程安全的，但修改任何给定键的实际值不是（我实际上指的是该对象的值或状态）。

我只是对它是如何工作的感到困惑，目前我认为事情是这样的。

ConcurrentHashMap就设置/获取它们而言，密钥的唯一保证是线程安全的。但是您放在地图中的对象必须自己保护并发。

它是否正确？

如果使用 EJB3 Singleton Session Bean，那么有 ConcurrentHashMap 状态变量是没有意义的——对吗？我可以只使用由容器并发管理器管理的常规 HashMap 吗？

我正在使用 ConcurrentHashMap 来缓存我在 SocketChannel 上处理的任务。StreamTask 是一个 Runnable，用于在客户端服务器通信期间超过往返阈值时重新调度自身，因此如果时间过去，它将自己从缓存中删除。此外，StreamWriteTask 线程会将其放在缓存中，而 StreaReadTask 将尝试将其删除。

问题是当我调用“processingCache.put()”时，它并不总是添加到地图中。

我对struts和java比较陌生。我一直在尝试理解以下代码。

关于“PRDCT_SVC_IND”周围的代码块，列名如何映射到 labelvaluebean？
虽然我对并发映射和键值对功能有一个想法，但我对这里的大多数概念都不太确定，并且尝试在互联网上搜索但没有太多运气。我希望更清楚地了解上述行的实际含义（当然，一般来说），就这里使用的概念而言，如 concurrenthashmap、list(labelvaluebean) 等。任何输入将不胜感激。

有人知道 ConcurrentHashMap 的内存开销是多少（与“经典”HashMap 相比）？

• 在施工？
• 在插入元素时？

我的问题：如果我使用“只读”const_accessors，为什么我的程序会冻结？

它似乎被锁定了，从 API 描述来看，拥有一个访问器和多个 const_accessors 似乎是可以的，（作者，阅读器）。也许有人可以告诉我一个不同的故事。

我试图实现的目标是使用这个并发哈希映射并使其可用于 10-200 个线程，以便它们可以查找和添加/删除信息。如果您有比我正在使用的当前解决方案更好的解决方案，那么您也欢迎发布替代方案。

TBB 社区教程指南第 43 页描述了访问器的概念

I have a ConcurrentHashMap that exhibits strange behavior on occasion.

When my app first starts up, I read a directory from the file system and load contents of each file into the ConcurrentHashMap using the filename as the key. Some files may be empty, in which case I set the value to "empty".

Once all files have been loaded, a pool of worker threads will wait for external requests. When a request comes in, I call the getData() function where I check if the ConcurrentHashMap contains the key. If the key exists I get the value and check if the value is "empty". If value.contains("empty"), I return "file not found". Otherwise, the contents of the file is returned. When the key does not exist, I try to load the file from the file system.

On occasion, the ConcurrentHashMap will return the contents of a non-empty file (i.e. value.contains("empty") == false), however the line:

returns FALSE. I broke down the IF statement into two parts: if (reply != null) and if (!reply.contains("empty")). The first part of the IF statement returns TRUE. The second part returns FALSE. So I decided to print out the variable "reply" in order to determine if the contents of the string does in fact contain "empty". This was NOT the case i.e. the contents did not contain the string "empty". Furthermore, I added the line

Since the variable reply did not contain the string "empty" when I printed it out, I was expecting indexOf to return -1. But the function returned a value approx the length of the string i.e. if reply.length == 15100, then reply.indexOf("empty") was returning 15099.

I experience this issue on a weekly basis, approx 2-3 times a week. This process is restarted on a daily basis therefore the ConcurrentHashMap is re-generated regularly.

Has anyone seen such behavior when using Java's ConcurrentHashMap?

EDIT

我正在编写用于文本处理的代码，如果我先将字符串转换为整数，事情会变得更快。为此，我创建了一个 Dictionary 类，每次我看到一个新字符串时，我都会给它一个索引，并保留两个映射，一个从 string 到 int，一个从 int 到 string，所以我可以轻松地查找两种方式. 这是代码：

在我的单线程代码中，这对我来说效果很好。但现在我想给这个多个线程以加快速度，我不知道该怎么做。我想过使用 ConcurrentHashMap，但我不确定这putIfAbsent是否能保证我不会使用索引两次。我不想使用 Collections.synchronizedMap，因为这个字典在线程之间被非常频繁地访问，所以我可能不会比使用单个线程更好，因为它在每次读取和写入时都会阻塞。有没有办法使这项工作？

我们正在用 C++ 开发一个高性能的关键软件。我们需要一个并发哈希映射并实现一个。因此，我们编写了一个基准来确定我们的并发哈希映射与std::unordered_map.

但是，std::unordered_map似乎非常慢......所以这是我们的微基准（对于并发映射，我们产生了一个新线程以确保锁定不会被优化，并注意我从不插入 0，因为我也用google::dense_hash_map,需要一个空值）：

（编辑：整个源代码可以在这里找到：http: //pastebin.com/vPqf7eya）

结果std::unordered_map是：

对于google::dense_map：

对于我们手动支持的并发映射（它会锁定，尽管基准是单线程的 - 但在单独的生成线程中）：

如果我在没有 pthread 支持的情况下编译基准程序并在主线程中运行所有内容，我会为我们的手动支持并发映射得到以下结果：

我使用以下命令进行编译：

因此，特别是插入std::unordered_map似乎非常昂贵 - 35 秒与其他地图的 3-5 秒。查找时间似乎也很长。

我的问题：为什么会这样？我在stackoverflow上阅读了另一个问题，有人问，为什么std::tr1::unordered_map比他自己的实现慢。有最高评价的答案状态，std::tr1::unordered_map需要实现更复杂的接口。但是我看不到这个论点：我们在 concurrent_map 中std::unordered_map使用存储桶方法，也使用存储桶方法（google::dense_hash_map没有，但至少std::unordered_map应该比我们手动支持的并发安全版本一样快？）。除此之外，我在界面中看不到任何强制使哈希映射表现不佳的功能...

所以我的问题是：std::unordered_map看起来很慢是真的吗？如果不是：有什么问题？如果是：那是什么原因。

而我的主要问题是：为什么将一个值插入到std::unordered_map如此可怕的代价中（即使我们一开始就保留了足够的空间，它的性能也不会好很多——所以重新散列似乎不是问题）？

编辑：

首先：是的，提供的基准并不是完美无缺的——这是因为我们用它玩了很多，它只是一个 hack（例如uint64，生成整数的分布实际上不是一个好主意，在循环中排除 0有点愚蠢等等......）。

目前大多数评论都解释说，我可以通过为 unordered_map 预先分配足够的空间来使其更快。在我们的应用程序中这是不可能的：我们正在开发一个数据库管理系统，并且需要一个哈希映射来存储事务期间的一些数据（例如锁定信息）。因此，此映射可以是从 1（用户只需进行一次插入和提交）到数十亿个条目（如果发生全表扫描）的所有内容。在这里预先分配足够的空间是不可能的（刚开始分配很多会消耗太多的内存）。

此外，我很抱歉，我没有足够清楚地说明我的问题：我对快速制作 unordered_map 并不感兴趣（使用谷歌的密集哈希图对我们来说很好），我只是不明白这种巨大的性能差异来自哪里. 它不能只是预分配（即使有足够的预分配内存，密集映射比 unordered_map 快一个数量级，我们的手动支持并发映射从大小为 64 的数组开始 - 所以比 unordered_map 小）。

那么造成这种不良表现的原因是std::unordered_map什么呢？或者换一种方式问：是否可以编写一个std::unordered_map符合标准并且（几乎）与谷歌密集哈希图一样快的接口实现？或者标准中是否有一些东西强制实施者选择一种低效的方式来实施它？

编辑2：

通过分析，我看到大量时间用于整数除法。std::unordered_map使用素数作为数组大小，而其他实现使用 2 的幂。为什么要std::unordered_map使用素数？如果散列不好，性能更好？对于良好的哈希值，恕我直言没有任何区别。

编辑 3：

这些是 的数字std::map：

Sooooooo：为什么插入std::map比插入更快std::unordered_map...我的意思是WAT？std::map具有更差的局部性（树 vs 数组），需要进行更多分配（每次插入 vs 每次重新哈希 + 每次冲突加上 ~1），最重要的是：具有另一个算法复杂性（O（logn） vs O（1））！

我使用并发哈希图来创建矩阵。它的指数范围为 100k。我创建了 40 个线程。每个线程访问矩阵的这些元素并对其进行修改并将其写回矩阵为：

我没有发现它是线程安全的。值经常返回为 null 并且我的程序正在崩溃。有没有其他方法可以使其线程安全。或者这是线程安全的，我在其他一些地方有错误。一件事是我的程序不会在单线程模式下崩溃。