ConcurrentHashMap put()方法可能不是线程安全的吗？
ConcurrentHashMap 是 Java 中的一个线程安全的哈希表实现，它可以在多线程环境下高效地进行并发操作。但是，即使在 ConcurrentHashMap 中，put() 方法在特定情况下也可能不是线程安全的。
当多个线程同时执行 put() 方法并尝试往 ConcurrentHashMap 中插入新的键值对时，可能会发生以下情况：
- 线程 A 和线程 B 同时执行 put() 方法，并且都认为哈希表中不存在要插入的键。
- 线程 A 执行完哈希计算，将键值对插入到哈希表中，并释放锁。
- 线程 B 也执行完哈希计算，并且发现相同的键正在哈希表中，于是线程 B 覆盖了线程 A 插入的键值对。
- 线程 A 和线程 B 都认为插入操作已经成功。
上述情况中，线程 A 的插入操作被线程 B 覆盖，导致最终只有线程 B 的键值对存在于 ConcurrentHashMap 中，而线程 A 的插入操作被丢失。
为了解决这个问题，ConcurrentHashMap 使用了一种叫做分段锁（Segment）的机制。它将整个哈希表分为多个段，在每个段上都有一把锁。当线程执行 put() 方法时，只需要获取对应段的锁，其他段的操作不会受到影响。这样可以提高并发性能，并保证在多线程环境下的一致性。
对于上述的问题，如果发生在不同的段上，则不会出现覆盖的情况，因为每个段都有独立的锁。但如果发生在同一个段上，则可能会有覆盖的风险。
为了避免这种情况，可以考虑使用 ConcurrentHashMap 的 putIfAbsent() 方法，该方法只在键不存在时插入键值对，避免了覆盖的问题。
腾讯云提供了基于云原生技术的分布式缓存产品TencentDB for Redis，它提供了高性能、高并发、高可靠的缓存服务，可以作为 ConcurrentHashMap 的替代方案。您可以在腾讯云的官方网站上查找更多关于 TencentDB for Redis 的详细信息和产品介绍。
参考链接：
相关·内容
3回答
我有一个用于生成随机值并将这些随机值放入hashmap的类。但是我已经将测试套件配置为能够执行paralley。所以，我声明了构造器是私有的，是线程安全的这个哈希图。这个机制正确吗？如果它是不正确的，我如何实现它？
public class RandomData{
private static Hashmap map = new Hashmap();
private RandomData(){}
public String getRandomVal(){
/* generate random value and put the map, if t
浏览 36提问于2020-03-13得票数 2
4回答
Java字节数组多线程
、、、、
如果我有多个线程访问getter和setter，这段代码会遇到竞争条件吗？我不介意getter在set操作期间获取旧数据，但前提是它不会导致异常或获取空值。
ConcurrentHashMap<String, Object> hashMap =
new ConcurrentHashMap<String, Object> ();
void setByteArray(String string, byte[] byteArray) {
hashMap.put(string, byteArray.clone());
}
byte[] getByteArra
浏览 0提问于2012-11-20得票数 6
回答已采纳
如果我使用ConcurrentHashMap ( put是线程安全的)，并且我提供了一个使用ConcurrentHashMap put的公共函数myPut -我需要同步我的函数吗？
含义:这应该同步吗？
ConcurrentHashMap map;
public void myPut(int something) {
this.map.put(something);
}
浏览 1提问于2008-11-19得票数 3
回答已采纳
1回答
我需要双键并发hashmap。
我的第一次尝试就是使用java.util.concurrent.ConcurrentHashMap.像这样
ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
map.put("key1" + "|" +"key2", "value");
String vaule = map.get("key1" + "|" +"key2");
但我觉得这很难看。
浏览 5提问于2017-06-02得票数 2
回答已采纳
我已经有一段时间没有将hashtable用于任何重要的事情了，但我似乎还记得get()和put()方法是同步的。
JavaDocs没有反映这一点。他们只是说类Hashtable是同步的。我能假设什么呢？如果多个线程同时访问哈希表(假设它们没有修改相同的条目)，操作将会成功，对吧？我想我要问的是“java.util.Hashtable线程安全吗？”
请指引我走出这个问题……
浏览 0提问于2011-09-13得票数 9
回答已采纳
2回答
如果使用ConcurrentHashMap作为映射，我会问自己，实现线程安全的正确方法是什么？
我在一本书里发现了这样的东西：
private ConcurrentHashMap<KEY, VALUE> cache = new ConcurrentHashMap<>();
public V put(KEY key, VALUE value) {
VALUE ret = cache.get(key);
if (ret == null) {
ret = cache.putIfAbsent(key, value);
if (r
浏览 7提问于2013-08-21得票数 2
回答已采纳
我们有一个共享的ConcurrentHashMap，它由两个线程读写。
class Test {
private ConcurrentHashMap<Object, Object> map = new ConcurrentHashMap<>();
Object read() {
return map.get(object);
}
void write(Object key, Object object) {
map.put(key, object);
}
}
我们是否需要使map易失性，以便读取
浏览 0提问于2015-04-02得票数 47
1回答
给出了一个多线程环境。下面的虚拟类有一个Map属性，它是在创建实例时用值初始化的。map的键是一个字符串，而值是一个布尔值，它将指示相应的条目当前是否由其他人(另一个线程)使用，或者是否可供使用。我希望这个映射在所有访问线程之间共享，条件是每个人都可以立即看到条目更新是否发生(表明相应的条目刚刚被拾取或释放)。实现这一目标的适当和最安全的方法是什么？如果我将map属性标记为volatile，而这两个方法是同步的，它会起作用吗？(下一步是使用等待逻辑对其进行增强，因此如果没有可用条目，线程可以等到某个时间段之后才抛出异常。)
public class Dummy {
private M
浏览 0提问于2021-04-29得票数 0
2回答
我在一次面试中被问到一个问题。如果我想像这样在地图中存储值，该怎么办：
key_1 --> value 1
key_2 --> value 2
key_1 --> value 3
在这里，如果我们假设键和值都在字符串中，那么我们应该使用如下的地图..
Map<String,List<String>> m1 = new HashMap();
然后我被问到如果你想实现线程安全怎么办？然后我说我们可以用ConcurrentHashMap来做这个，purpose..they说，好的。
然后，他们问，价值，我的意思是，列表是线程安全？例如。
t1.get(
浏览 0提问于2019-04-25得票数 1
回答已采纳
基本上，我们倾向于在多线程环境中使用ConcuttentHashMap。我目前的代码如下：
ExecutorService executor = Executors.newFixedThreadPool(3);
Map<String, Future<String>> myMap = new HashMap<String, Future<String>>();
myMap.put("SomeValue", executor.submit(() -> return callAndReturnStringMethod("S
浏览 2提问于2020-11-23得票数 4
回答已采纳
4回答
当从多个线程调用方法addId时，会出现竞争条件吗？
private static Map<String , Long> table;
static {
table = new ConcurrentHashMap<String , Long>();
}
public static void addId(String key, Long value){
if(table.containsKey(key)){
table.remove(key);
}
table.put(key, value);
}
浏览 0提问于2011-06-22得票数 1
回答已采纳
哈希表和Collections.synchronizedMap是线程安全的，但仍然是复合操作，如
if (!map_obj.containsKey(key)) {
map_obj.put(key, value);
}
需要外部同步，因为：
synchronized(map_obj) {
if (!map_obj.containsKey(key)) {
map_obj.put(key, value);
}
}
假设我们有ConcurrentHashMap(CHM)，而不是Hashtable或HashMap。CHM为上述复合操作提供了一种替代的putIfAbse
浏览 9提问于2014-02-09得票数 11
4回答
这个线程安全吗？
、、
这个线程安全吗？我需要锁吗？
public class Load {
//private final Object lock = new Object();
private final Map<String, String> confs = new HashMap<String, String>();
public void addValue(String key, String value) {
//synchronized (lock)
confs.put(key, value);
}
publ
浏览 0提问于2014-05-16得票数 0
6回答
我有一个从许多线程中调用的DAOClass，如下所示，用于插入到一组表中-
public class DAOClass
{
private HashMap<String, HelperClass> insertBuffer;
public DAOClass()
{
insertBuffer = new HashMap<String, HelperClass>();
}
public int[] createSomeTable(String key, SomeTableRecord someTableRecord)
{
Li
浏览 0提问于2013-02-20得票数 1
回答已采纳
8回答
这段代码是线程安全的吗？
、、、
我想处理一个客户端请求流。每个请求都有其特殊的类型。首先，我需要为该类型初始化一些数据，然后就可以开始处理请求了。当客户端类型第一次出现时，我只是初始化相应的数据。在此之后，将使用该数据处理该类型的所有后续请求。
我需要以一种线程安全的方式来做这件事。
这是我写的代码。它是线程安全的吗？
public class Test {
private static Map<Integer, Object> clientTypesInitiated = new ConcurrentHashMap<Integer, Object>();
/* to proces
浏览 0提问于2012-09-19得票数 6
回答已采纳
在文献中您可以发现，ConcurrentHashMap比HashTable快得多。我只是想知道为什么下面的代码没有显示这一点。
在下面的代码中，在ConcurrentHashMap (chm)和HashTable (ht)中都填充了一些数字。有两个等价的可调用函数(一个用于chm，另一个用于ht)，它们对chm或ht元素执行相同的操作，并以毫秒为单位返回执行时间。
ht的执行时间只有chm的一半。
public class ConcurrentHashMapDemo {
static ConcurrentHashMap<Long, Double> chm;
sta
浏览 0提问于2014-11-13得票数 1
当2个线程访问该异常时，下面的代码将接收并发修改异常。
我想知道
如果使用并发Hashmap，是否可以避免此异常。
如果我们使用并发hashmap，那么多线程环境中会出现任何问题。
或者还有其他方法来防止这种异常呢？
我不打算使用同步，因为这段代码是在轮询期间使用的。因为一个线程可能要等待另一个线程完成解释。
代码是
HashMap<Integer, myModel> aServiceHash = new HashMap<Integer, myModel>();
HashMap<Integer, myModel> rServiceHash =
浏览 3提问于2014-11-27得票数 0
回答已采纳
4回答
我有一段Java代码，它通过以下方式在哈希表中搜索值：
class HTDemo {
public static void main(String args[]) {
Hashtable balance = new Hashtable();
double bal;
balance.put("John Doe", new Double(3434.34));
balance.put("Tom Smith", new Double(123.22));
balance.put(
浏览 0提问于2012-07-30得票数 2
回答已采纳
我有一个CuncurrentHasMap：
private static ConcurrentHashMap<String, Object> testParameters =
new ConcurrentHashMap<String, Object>();
我用相同的键推(有时)对象，这些对象是TreeMaps类型的TreeMap(string，MyPrivateClass)。
如何更改这个put方法，以便将具有相同键的对象放在一起而不被重写？
public static void put(String key, Object object) {
ge
浏览 0提问于2018-11-26得票数 0
回答已采纳
有一个包含final字段的服务。
@Service
public class RegularService {
private final DataMap map = new DataMap();
....
}
此final字段具有DataMap类，如下所示
class DataMap {
private Map<UUID, String> content1 = new HashMap<>();
private Map<UUID, String> content2 = new HashMap<>();
v
浏览 0提问于2019-10-27得票数 0
3回答
我想避免并发修改异常。所以要做一个哈希图的拷贝。即使这样，它在从原始map中删除元素的同时也会抛出并发修改。下面是要复制的代码，有什么错误吗？
private HashMap<String, ArrayList<String>> makeCopy(HashMap<String, ArrayList<String>> origMap) {
HashMap<String, ArrayList<String>> copy=new HashMap<String, ArrayList<String>>
浏览 2提问于2015-07-21得票数 0
我试图理解我在流文档中发现的警告。我养成了使用forEach()作为通用迭代器的习惯。这导致我编写了这种类型的代码：
public class FooCache {
private static Map<Integer, Integer> sortOrderCache = new ConcurrentHashMap<>();
private static Map<Integer, String> codeNameCache = new ConcurrentHashMap<>();
public static void p
浏览 3提问于2017-10-31得票数 11
回答已采纳
3回答
下面提供了一组代码：
Map<String, BigDecimal> salesMap = new HashMap<>();
orderItems.parallelStream().forEach(orderItem -> {
synchronized (this) {
int itemId = orderItem.getItemId();
Item item = settingsClient.getItemByItemId(itemId);
浏览 7提问于2020-06-15得票数 0
回答已采纳
我有一个函数，它的目的是防止并发修改异常列表parseObjectKeys =newArrayList<>(parseObject.keySet())；然而，这种情况仍然时有发生。
private static void convertParseObject(ParseObject parseObject,
HashMap<String, HashMap<String, WritableMap>> topLevel,
浏览 0提问于2018-10-11得票数 1
回答已采纳
ConcurrentHashMap的Java说，
即使所有操作都是线程安全的。
当我们说ConcurrentHashMap的所有操作都是线程安全的时候，意味着什么？
编辑：，我想问的是，假设有put()操作。然后，根据上面的声明，CHM中的put()是线程安全的。这是什么意思？
浏览 3提问于2014-02-03得票数 0
回答已采纳
我知道ConcurrentHashMap是线程安全的e.g.putIfAbsent，替换等等，但我想知道，下面的代码块是否安全？
if (accumulator.containsKey(key)) { //accumulator is a ConcurrentHashMap
accumulator.put(key, accumulator.get(key)+1);
} else {
accumulator.put(key, 0);
}
请记住，键的累加器值可能由两个不同的线程同时询问，这将导致正常HashMap中的问题。我需要这样的东西吗？
ConcurrentHashMa
浏览 0提问于2016-02-12得票数 0
回答已采纳
我有一个，由8个不同的线程填充put。8条线程中的一条试图使用forEach使用者进行读取。我的问题是，ConcurrentHashMap只有5-7个条目.
map.put(myContent);
...
map.forEach(element -> ... do something);
如果我添加了一个，它会显示所有的8个条目
map.put(myContent);
map.size();
...
map.forEach(element -> ... do something);
遍历表明，迭代映射并不是真正的线程安全。没有确保获得所有条目：
对于聚合操作(如putAll和
浏览 0提问于2018-03-15得票数 1
回答已采纳
在Test.java中
public static Map<String, Integer> testMap=new HashMap<String, Integer>();
在TestServlet.java中
public void doGet(HttpServletRequest req, HttpServletResponse resp)
throws IOException {
Test.testMap.put("cool", 1);
}
在TestServlet2.java中
public void doGet(Ht
浏览 0提问于2016-01-14得票数 1
回答已采纳
类的主要目的是充当事件总线，多个线程可以通过它注册/注销模型。
public class ThreadSafeHash {
private final HashMap<String, LinkedList<Model>> modelMap = new HashMap<>();
public boolean addModel(final String category, final Model model) {
LinkedList<Model> categoryContents = modelMap.get(ca
浏览 7提问于2016-02-03得票数 1
回答已采纳
我正在创建基于套接字的服务器-客户端预订服务，并且存在由多个线程访问的类的问题，它需要扩展ConcurrentHashMap，还是只需要创建变量ConcurrentHashMap以保证线程安全？
我有两个想法，但我不确定第一个想法是否有效，所以第一个想法是创建一个类，它只实现Serializable有可变日期，然后是变量ConcurrentHashMap (线程想在其中操作)；第二个想法是拥有扩展并发Hash Map的类，它只是CHP，但是有附加变量，以确保它与其他类的区别。
public class Day implements Serializable {
private LocalDat
浏览 0提问于2019-01-06得票数 2
回答已采纳
2回答
下面的代码有什么问题吗？
private Map<Integer, Integer> aMap = new ConcurrentHashMap<Integer, Integer>();
Record rec = records.get(id);
if (rec == null) {
rec = new Record(id);
records.put(id, rec);
}
return rec;
上面的代码不是线程安全吗？在这种情况下，我为什么要在这里使用putIfAbsent？
锁定仅适用于更新。在检索时，它允许完全
浏览 0提问于2013-09-29得票数 0
回答已采纳
我有以下代码：
public class MySystem {
private ConcurrentHashMap<Integer, Integer> disabledList = new ConcurrentHashMap<>();
public void toggle(int id) {
synchronized (disabledList) {
if (disabledList.containsKey(id)) {
disabledList.remove(id);
浏览 3提问于2016-03-09得票数 0
8回答
我读了很多，但还没有找到一个明确的答案。
我有一个看起来像这样的类：
public class Foo() {
private static final HashMap<String, HashMap> sharedData;
private final HashMap myRefOfInnerHashMap;
static {
// time-consuming initialization of sharedData
final HashMap<String, Str
浏览 0提问于2010-03-10得票数 30
回答已采纳
我正在创建一个具有以下特性的回忆录缓存：
缓存丢失将导致计算和存储条目。
这种计算非常昂贵。
这种计算是幂等的。
从：开始无界(条目从未移除)
输入最多将产生500个条目。
每个存储的条目都非常小。
缓存的寿命相对较短(通常不到一个小时)。
总的来说，内存的使用不是一个问题
在缓存的生命周期中，将有成千上万的读操作，我预计99.9%+缓存会命中
必须是线程安全的
什么样的解决方案具有优越的性能，或者在什么条件下，一种解决方案比另一种方案更受青睐？
ThreadLocal HashMap：
class MyCac
浏览 2提问于2013-01-12得票数 9
回答已采纳
我有一个关于线程安全和HashMaps的问题.更具体地说，我想知道是否有一个线程在被写入HashMap时尝试从它读取。下面是一个粗略的例子：
我有一门课叫"TestClass"：
public class TestClass implements Runnable {
// New thread
TestThread testThread = new TestThread();
@Override
public void run() {
// Starts the thread.
testThread.sta
浏览 0提问于2017-07-30得票数 0
回答已采纳
2回答
这个线程在java中安全有效吗？
、、、、
public class Test {
static ConcurrentHashMap<Integer, Integer> map = null;
final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public static void open() {
lock.writeLock().lock();
try {
if (map != null) {
return;
}
map = new C
浏览 4提问于2019-03-07得票数 0
回答已采纳
4回答
我正在尝试创建一个具有Map值的int值，并通过多个线程来增加它们。两个或多个线程可能会增加相同的键。
ConcurrentHashMap文档对我来说非常不清楚，因为它说明：
Retrieval operations (including get) generally do not block, so may overlap with update operations (including put and remove)
我想知道以下使用ConcurrentHashMap的代码是否正确地工作
myMap.put(X, myMap.get(X) + 1);
如果没有，我又如何处理这些事情呢？
浏览 4提问于2012-08-27得票数 12
回答已采纳
我对ArrayList的安全出版物有一些怀疑。
我有密码：
private final Map<Long, SomeStuff> map = new ConcurrentHashMap<>();
//Called by Thread 1
public void write() {
List list = new ArrayList<>();
for (int i = 0; i <100 ; i++) {
list.add(new SomeStuff(i))
}
map.put(1L,list)
}
// Called
浏览 1提问于2017-07-12得票数 1
回答已采纳
在执行以下代码时，我将得到一个并发修改异常：
mymap是一个全局变量，是一个HashMap。
Callable<String> task = new Callable<String>() {
@Override
public String call() {
mymap.put("myid", "id2");
mymap.put("myname", "joe");
String id = mymap.get("myid"
浏览 3提问于2014-01-31得票数 0
1回答
在我使用ConcurrentHashamp的地方，我正在实现一个客户端查找映射。
private ConcurrentHashMap<String,SignupDTO> map = new <String,SignupDTO> ConcurrentHashMap();*
public SignupDTO get(String opcode)
{
return this.map.get(opcode);
}
public void set(String opcode,SignupDTO dto)
{
浏览 1提问于2014-06-16得票数 0
2回答
假设我有以下代码：
private ConcurrentHashMap<Integer, Book> shelf;
public Library(ConcurrentHashMap<Integer, Book> shelf){
this.shelf = new ConcurrentHashMap<Integer, Book>(shelf);
}
假设我使用的是线程安全集合，那么下面的方法可以使用，还是需要担心线程安全？
public void addBook(int index
浏览 3提问于2016-02-05得票数 0
回答已采纳
2回答
我正在尝试一个使用ConcurrentHashMap实现故障安全的例子。
下面是我试过的样本片段。
ConcurrentHashMap<String, String> cMap = new ConcurrentHashMap<String, String>();
cMap.put("1", "Windows Phone");
cMap.put("2", "iPhone");
cMap.put("3", "HTC");
Iterator iterator=cMap.keySe
浏览 1提问于2014-09-05得票数 5
回答已采纳
它将用于键映射字符串对象值。比方说，myObject = struct.get("first")；排序并不重要。
参数化的Hashset还是其他更好的？
如果这不困扰你，你能给我一个静态初始化和声明的例子，一个更简单的结构，例如(字符串-字符串键映射)吗？
浏览 1提问于2010-02-19得票数 0
回答已采纳
当有多个线程从其他方法中调用totalBadRecords()方法时，线程/并发下面的代码是否安全？该方法的两个映射对象参数都是ConcurrentHashMap。我想确保每个呼叫正确地更新总数。
如果不安全，请解释我要做什么来确保线程安全。
我是否需要同步添加/放置，还是有更好的方法？
我需要同步TestVO中的get方法吗？TestVO是简单的java，具有getter/setter方法。
下面是我的示例代码：
public void totalBadRecords(final Map<Integer, TestVO> sourceMap,
final
浏览 8提问于2013-09-09得票数 0
回答已采纳
6回答
这是JavaDoc关于ConcurrentHashMap的一篇文章。它说，检索操作一般不会阻塞，因此可能与更新操作重叠。这是否意味着get()方法不是线程安全的？
“然而，即使所有操作都是线程安全的，检索操作也不需要锁定，也不支持以阻止所有访问的方式锁定整个表。这个类在依赖线程安全但不依赖其同步细节的程序中与Hashtable完全可互操作。
检索操作(包括get)一般不阻塞，因此可能与更新操作(包括put和remove)重叠。检索结果反映了最近完成的更新操作的结果。
浏览 0提问于2013-02-19得票数 57
我有一个数据结构HashMap<String, HashMap<String, String>>现在我需要增加这个数据结构的踏面安全性，我应该使用哪一个呢？
ConcurrentHashMap<String, HashMap<String, String>>
或
ConcurrentHashMap<String, ConcurrentHashMap<String, String>>
这两者有什么区别？
浏览 3提问于2022-09-25得票数 0
回答已采纳
2回答
我有低年级的
public class LRUCache {
private HashMap<String,String> dataMap;
private HashMap<String,String> analyticsMap;
public put(String key, String value) {
dataMap.put(key, value);
String date = getCurrentDateAsString();
analyticsMap.put(key, date);
}
浏览 1提问于2018-10-25得票数 0
回答已采纳
4回答
我正在多线程环境上编码，我看到线程被卡在HashMap.put上。
34 Threads
java.util.HashMap.put(HashMap.java:374)
com.aaa.bbb.MyClass.getDefinitionMap().
通过研究HashMap方法，我发现该方法是同步的：
@Override
public synchronized Map<String,String> getDefinitionMap() {
//truncated some code here...
colDefMap = new HashMap
浏览 4提问于2016-07-14得票数 2
回答已采纳
嗨，当我为下面的代码在我的项目中运行find时，我得到了bug“对java.util.concurrent.ConcurrentHashMap的调用序列可能不是原子的”。
public static final ConcurrentHashMap<String,Vector<Person>> personTypeMap = new ConcurrentHashMap<String, Vector<Person>>();
private static void setDefaultPersonGroup() {
Per
浏览 5提问于2014-01-21得票数 10
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
