确定'put‘操作是否在ConcurrentHashMap的putIfAbsent方法中实际执行？
在ConcurrentHashMap的putIfAbsent方法中，如果指定的键不存在，则会执行put操作。put操作会将指定的键值对插入到ConcurrentHashMap中。如果指定的键已经存在，则不会执行put操作，返回已存在的值。
ConcurrentHashMap是Java中线程安全的哈希表实现，它支持高并发的读写操作。putIfAbsent方法是ConcurrentHashMap提供的一个原子操作，用于在键不存在时插入键值对。该方法的执行过程如下：
- 首先，ConcurrentHashMap会根据键的哈希值确定该键应该存储在哪个桶中。
- 然后，ConcurrentHashMap会尝试获取该桶的锁，以确保并发操作的安全性。
- 如果指定的键不存在于该桶中，ConcurrentHashMap会执行put操作，将键值对插入到该桶中，并返回null。
- 如果指定的键已经存在于该桶中，ConcurrentHashMap不会执行put操作，直接返回已存在的值。
ConcurrentHashMap的putIfAbsent方法适用于需要在多线程环境下插入键值对的场景，可以保证插入操作的原子性和线程安全性。
腾讯云提供了一系列与云计算相关的产品，其中包括云服务器、云数据库、云存储等。对于ConcurrentHashMap的应用场景，可以考虑使用腾讯云的云服务器来搭建高并发的应用程序，使用云数据库来存储数据，使用云存储来存储大量的文件和对象。
腾讯云云服务器产品介绍链接：https://cloud.tencent.com/product/cvm 腾讯云云数据库产品介绍链接：https://cloud.tencent.com/product/cdb 腾讯云云存储产品介绍链接：https://cloud.tencent.com/product/cos
相关·内容
我有一个关于ConcurrentHashMap的问题。
ConcurrentHashMap是用于并发访问的映射。ConcurrentHashMap实现了扩展Map的ConcurrentMap。
a) ConcurrentHashMap实现了在ConcurrentMap中定义的方法(如putifAbsen、t等)，这些方法是原子的。
b)但是，ConcurrentMap扩展的Map接口中的方法又如何呢？它们现在是怎么变成原子的呢？它们是否已由ConcurrentHashMap重新实现
如果我有一个类型为ConcurrentHashMap的引用，并从Map接口(例如put)或任何其他方法调用一个方
浏览 2提问于2013-09-05得票数 0
我深入研究了并发性，并且真的很难理解并发数据结构中使用的一些设计，即并发散列映射。
我有一些声明和粗体的问题，请帮助我确认和回答。
putIfAbsent不能告诉执行线程它是实际用一个新值替换了键，还是使用了现有的旧值，因为在这两种情况下，它都将返回旧值。那么，在大多数用例中，我们实际上向终端客户/用户/关于操作结果报告的'putIfAbsent‘有什么意义呢?我知道这可能是泛化的，但仍然如此？我们中的大多数人可能会对Optional<Entry<K,V>> putIfAbsentAndReturnValueIfPut(K,V)感到高兴，就像这样:-)？
我从p
浏览 3提问于2017-03-15得票数 0
回答已采纳
1回答
当使用并发hashmap时，我需要将put包装在同步块周围，是否有可能出现争用状态：
synchronized(lock) {
if(this.map.get(id) != null) {
throw new Exception();
}
this.map.put(id, number);
return true;
}
浏览 3提问于2022-04-22得票数 0
回答已采纳
假设我有concurrentHashMap代码，如下所示：
ConcurrentHashMap<Integer,Integer> balances = new ConcurrentHashMap<>();
public void add(int accountId, int amountToAdd){
int currentBalance = balances.get(accountId);
balances.put(accountId, currentBalance + amountToAdd);
}
此add方法是从多个线程调用的，可以尝试同时
浏览 0提问于2016-05-18得票数 0
回答已采纳
这就是问题所在:我们需要一个哈希表，其条目是线程安全的。
假设我有一个<String, Long>哈希表，并且希望安全地增加其中一个条目线程的值:以下是否确定？：
HashMap<String , Long> hashTable = new HashMap<String, Long>();
然后每当我想增加一个条目时：
Synchronized (hashTable.get("key"))
{
Long value = hashTable.get("key");
value++;
hashTable.p
浏览 3提问于2016-07-19得票数 1
回答已采纳
我是java世界的新手，在探索并发散列映射时，我发现了putifAbsent()方法。
public V putIfAbsent(K paramK, V paramV)
{
if (paramV == null)
throw new NullPointerException();
int i = hash(paramK.hashCode());
return segmentFor(i).put(paramK, i, paramV, true);
}
现在请告知它的功能是什么，我们什么时候实际需要它，如果可能的话，请解释一个小的简单的例子。
浏览 1提问于2013-04-06得票数 2
我需要在Java中编写一个散列映射，它将跨线程使用，主要用于读取。考虑这样一种情况:客户端只向散列映射写入一次(最多只有10或15个条目)，但是键和值来自客户端。这意味着我不知道advance.After中的键/值对，一旦写入它们，它们会同时读取很多次。
以一种高效的方式更像以下代码片段：
public String getPS(String query) {
//put into map if not present
if(psMap.get(query) == null){
synchronized (this) {
if(psMap
浏览 0提问于2015-03-05得票数 1
我正在尝试以线程安全的方式支持以下数据结构的修改(deactivate()函数调用)-
private static Map<String, Set<Integer>> dbPartitionStatus = new HashMap<String, Set<DBPartitionId>>();
public void deactivate(DBPartitionId partition) throws Exception {
synchronized (dbPartitionStatus) {
Set<DBPa
浏览 0提问于2013-02-08得票数 2
4回答
从多个线程填充映射
、、、
我有一个ConcurrentHashMap，它是从多个线程填充的，如下所示：
private static Map<ErrorData, Long> holder = new ConcurrentHashMap<ErrorData, Long>();
public static void addError(ErrorData error) {
if (holder.keySet().contains(error)) {
holder.put(error, holder.get(error) + 1);
} else {
浏览 8提问于2015-12-21得票数 1
回答已采纳
我的项目中有以下代码
// Declaration
private ConcurrentHashMap<Long, ConcurrentHashMap<String, Object>> instanceSpecificBeanMap = new ConcurrentHashMap<>();
地图的使用
ConcurrentHashMap<String, Object> beanMapForInstance = instanceSpecificBeanMap.get(currentInstanceId);
Object beanObjec
浏览 1提问于2015-04-14得票数 3
回答已采纳
哈希表和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
我必须处理许多类，这些类用于在ConcurrentHashMap中存储数据，通常如下所示：
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;
public class Data {
private ConcurrentHashMap<String, SomeObject> concurrentHashMap = new ConcurrentHashMap<String, SomeObject>();
priva
浏览 1提问于2014-03-03得票数 0
回答已采纳
我想使用包含一些结果的并发散列映射，
ConcurrentHashMap<Long,AtomicInteger>
如果键不存在，则添加一个新条目，或者按键和增量获取值，如下所示：
if(map.contains(key))
map.get(key).addAndGet(1);
else
map.put(key,new AtomicInteger(1));
放置操作不安全，如何解决这个问题？放置操作应该在同步块内吗？
浏览 5提问于2016-03-29得票数 8
回答已采纳
从Javadoc我知道ConcurrentHashMap.replace是原子的，但是ConcurrentHashMap.put呢？我看到它们在源代码中的实现是不同的，但我不能弄清楚它们的区别。关于如何使用这两种方法，有没有大师能给出一些指导？
浏览 0提问于2012-08-15得票数 9
回答已采纳
嗨，当我为下面的代码在我的项目中运行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
回答已采纳
我有一个ConcurrentMap<String，SomeObject>对象。我想要编写一个方法，如果SomeObject值存在，它将返回，或者创建一个新的SomeObject，把它放到Map中，如果它不存在，则返回它。
理想情况下，我可以使用ConcurrentMap的putIfAbsent(key, new SomeObject(key))，但这意味着我每次都要创建一个新的SomeObject(key)，这看起来非常浪费。
因此，我求助于以下代码，但不确定这是否是处理此问题的最佳方法：
public SomeValue getSomevalue(String key){
浏览 2提问于2017-03-13得票数 5
回答已采纳
我需要把一个条目到地图上，只有当钥匙还没有出现。对于Java 8，我只使用putIfAbsent，但是我在Java 7中使用Groovy。
说明问题的代码：
def map = [a: 1, b: 2, c: 3]
def newEntries = [a: 11, b: 22, d: 44]
def result = // put new entries to the map only if they are not present
assert result == [a: 1, b: 2, c: 3, d: 44]
是否可以使用Groovy特性来完成这个任务，还是需要手动完成呢？
浏览 5提问于2016-08-24得票数 3
回答已采纳
我试图澄清HashMap对ConcurrentHashMap的类型安全性和性能.我遇到了许多好文章，但仍有麻烦弄清楚了。
让我们以下面的示例为例，使用一个ConcurrentHashMap，其中我将尝试为一个尚未存在的键添加一个值并返回它，新的方法是：
private final Map<K,V> map = new ConcurrentHashMap<>();
return map.putIfAbsent(k, new Object());
假设我们不想使用putIfAbsent方法，上面的代码应该如下所示：
private final Map
浏览 4提问于2020-12-13得票数 0
回答已采纳
2回答
我有以下情况:我同时处理具有给定密钥的请求。只要进程中的每个键都是唯一的，我可以同时处理任意数量的请求。
我是一个在Java中具有并发性的新手。这方面肯定存在一些模式/实用程序/现有的问题，但我不知道该搜索什么。希望有人能给我指明正确的方向，或者评论我到目前为止的情况。
这个类管理锁：
class LockMap<K> {
private Map<K, Object> locks = new HashMap<>();
void acquireLock(K key) throws InterruptedException {
浏览 1提问于2014-01-22得票数 2
回答已采纳
3回答
队列的线程安全映射
、、、
我想实现一个线程安全的队列映射。
我打算从一张空地图开始。如果密钥不存在，我希望创建一个带有新队列的新Map条目。如果密钥确实存在，我希望将其添加到队列中。我建议的实施措施如下：
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
public class StackOverFlowExample {
private final Map<String, ConcurrentLinkedQue
浏览 1提问于2014-10-21得票数 1
回答已采纳
2回答
如何在并发环境中记录web请求？
、、、、
我们有一个每天接收大约100万个请求的web应用程序，我们使用一个拦截器来审计请求计数和响应状态，这个拦截器会调用一个带有spring注释的类，这个类基本上会将它们添加到一个映射中，并在经过配置的间隔之后保存映射。
由于我们有固定的api集合，所以我们维护API名称为键的ConcurrentHashMap映射，它的计数和响应状态对象为value.So，对于每个对api的请求，我们检查它是否存在于我们的映射中，如果存在，我们根据它获取对象，否则我们创建一个对象并将它放到map中。对于ex
class Audit{
CounterObject =null;
if(APIMap.co
浏览 4提问于2015-12-18得票数 2
2回答
假设我有一个注册到服务器的客户端ConcurrentHashMap (在类Server中)：
Map<ClientID, String> registeredClients = new ConcurrentHashMap<ClientID, String>();
在我的注册方法中(在Server类中)，我有：
public void synchronized register(ClientID client, String clientName) {
if(!registeredClients.containsKey(client))
浏览 0提问于2015-06-11得票数 1
在这种情况下，调用者希望根据当前实例(标识符)获取bean的对象。现在，如果bean的对象存在于当前实例，那么就不应该再次创建它。所以有两种方法(我认为)可以这样做-
1. Using putIfAbsent of ConcurrentHashMap
beanObject = objectFactory.get(); // this will create new instance every time
// even if not required
beanObject = beanMapForInstance.putIfAbsent(name, beanObject);
return b
浏览 5提问于2015-04-16得票数 1
回答已采纳
2回答
我正在尝试创建一个使用映射内设置线程安全的类。我不确定what是否特别需要同步。
地图被定义为类似于Map<Class<K>, Set<V>> map;的东西。以下是映射在实现中的内部使用方式的缩减：
public void addObject(K key, V object) {
getSet(key).add(object);
}
public void removeObject(K key, V object) {
getSet(key).remove(object);
}
public void iterateObjectsInt
浏览 1提问于2012-08-24得票数 2
我将一个由线程创建的对象缓存到一个映射中。创建对象非常昂贵，因此我不希望运行多个线程来创建对象，因为put()尚未返回。一旦线程试图为该键创建一个对象，其他线程就不应该尝试创建该对象，即使put尚未完成。使用computeIfAbsent()可以获得对特定密钥的“锁”吗？如果没有，是否有其他方法来实现这一目标？
浏览 1提问于2018-08-06得票数 6
回答已采纳
下面的方法线程安全吗？此方法在Singleton类中。
private static final Map<String, PreparedStatement> holder = new ConcurrentHashMap<>();
public BoundStatement getStatement(String cql) {
Session session = TestUtils.getInstance().getSession();
PreparedStatement ps = holder.get(cql);
if(ps == n
浏览 2提问于2016-11-27得票数 2
回答已采纳
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上执行所有非检索操作(put()、remove()等)需要包装在synchronized(this)块中吗？我知道所有这些操作都是线程安全的，那么这样做有什么实际的好处/需要吗？唯一使用的操作是put()和remove()。
protected final Map<String, String> mapDataStore = new ConcurrentHashMap<String, String>();
public void updateDataStore(final String key, final String value
浏览 0提问于2014-09-23得票数 39
回答已采纳
我正在做一个项目，在这个项目中，我要连接到数据库。如果有的话，我需要看一次exception is happening的次数。我正在使用Multithreaded code，这意味着多个线程将连接到数据库并插入数据库。因此，可能在某个时候连接会丢失，所以我们需要查看这些异常发生了多少次。
因此，我编写了下面的代码，在catch块中，我捕获异常，并在每次出现异常时设置一个计数器，并将其放入ConcurrentHashMap中。
class Task implements Runnable {
public static final AtomicInteger counter_sql_
浏览 5提问于2013-02-12得票数 4
回答已采纳
我有一个由线程访问的ConcurrentHashMap<String,List<String>>，该线程在追加值之前检查键是否存在。我在使用synchronized关键字时做到了这一点。如果不使用synchronized关键字，则值是错误的。ConcurrentHashMap线程安全不是吗？或者这个代码有问题吗？在不使用synchronized以获得更好的性能的情况下，是否有可能使此代码正常工作？下面是实现这一目的的代码。
ExecutorService executorService = Executors.newFixedThreadPool(4);
浏览 0提问于2015-10-28得票数 2
回答已采纳
1回答
映射具有可变键的并发性
、、、
I： Map<K1, Map<K2, V>>，其中：
K1是可变的。(它很少并且只在ine位置上更改，所以我只需删除K1的Map并使用另一个键重新设置它)
我想要的：使地图并发。我想同时：
修改K2的值(V)
替换K1的整个映射
更新的问题：下面的代码很容易出错吗？
public class V {
K1 k1;
K2 k2;
final ConcurrentHashMap<K1, ConcurrentHashMap<K2, V>> map = new ConcurrentHashMap<K1
浏览 1提问于2014-02-24得票数 0
回答已采纳
我正在编写一个实用工具类，它使用map作为缓存存储。现在，它将被用于多线程环境。我想出了在执行put操作时使用同步hashmap或使用ConcurrentHashMap(使用putIfAbsent)，但我仍然不知道它是否容易重写键值(虽然在我的情况下键值是唯一的)，两者都有优缺点。所以我无法决定。也许还有其他的缓存存储可以用于这个目的，但我更感兴趣的是，如果这是唯一的选择，我想知道哪个将用于CHM或Hashmap。
在对程序的评论中，我认为我使用了HashMap。
public final class DateTime {
private static final Map<Coun
浏览 0提问于2016-08-18得票数 0
我正在尝试执行一个映射值的线程安全获取器，如果它不存在，也会创建该值：
private final static Map<String, MyObject> myMap = new HashMap<String, MyObject>();
public MyObject myGetter(String key) {
// Try to retrieve the object without synchronization
MyObject myObject = myMap.get(key);
if (myObject != null) {
浏览 5提问于2016-10-18得票数 3
回答已采纳
我有一个Map<String,Object>要转换成一个ConcurrentMap<String,Object>
Map<String,Object> testMap = new HashMap<String,Object>();
testMap.put("test", null); //This null causing issues in conversion
testMap.put("test2","123");
testMap.put("test3&#
浏览 0提问于2019-01-15得票数 3
回答已采纳
我必须实现这样的逻辑，即只有在键当前未映射到任何值的情况下，才需要为键自动设置对象。我可以自己实现这一点，但如果它已经在某个地方完成了，我不想重新发明轮子。
浏览 0提问于2012-05-08得票数 0
回答已采纳
我正在努力学习多线程技术。假设我有一个类，它有一个向ConcurrentHashMap添加值的方法。
public void add(ConcurrentHashMap<Integer,String> map){
if(!map.containsKey(1){
map.put(1,"test");
}
}
如何确保不同的线程在向其添加元素时不删除特定值或删除整个映射。
我试图在add方法中同步(Map)，但这不起作用。
编辑1:我没有正确地设置它的框架，我的意思是如果其他线程使map为空，并且我无法访问使其为空的代码。如何避免添加方法中的空指针
浏览 3提问于2015-08-09得票数 0
回答已采纳
1回答
也许这个问题有答案，但根据我的搜索词，找不到最适合我的东西，所以把问题贴在这里。这个问题可能看起来很愚蠢，但这对我来说是新的东西。请提供一些建议或解决方法。
我有一个具有Map的Populator类。我希望在代码执行期间用各种值填充这个映射，最后我希望获得Map中的所有值，然后根据我的需求进一步处理它。
到目前为止，我正在使用Static method and variable来实现这一点。到目前为止，这似乎运行得很好。但我的导师建议我，当并行处理多个请求时，这将不是线程安全的。我想知道如何让下面的代码线程安全。
为了更好地理解，我会用代码来解释：
下面是我的Populcator.class，
浏览 1提问于2021-07-16得票数 0
我读过关于hashMap的文章，以及它与hashtable的不同之处。与哈希表中一样，完整的对象被锁定，而在并发哈希映射的情况下，只有一部分被锁定。我的问题是，当两个线程试图在samme时访问一个键的相同值时会发生什么。
让我们说
Map mp = new ConcurrentHashMap();
mp.put(1, "Hello");
线程1:尝试读取mp.get(1)。
线程2:尝试编写/修改mp.put(1，"Hi")。
那么线程1读取的值是什么呢？
编辑:我是说ConcurrentHashMap。
浏览 2提问于2016-04-03得票数 3
回答已采纳
2回答
我有一个下面的Singleton类，在我的getStatement方法中，我通过执行if检查来填充CHM。
public class CacheHolder {
private static final Map<String, PreparedStatement> holder = new ConcurrentHashMap<>();
private static class Holder {
private static final CacheHolder INSTANCE = new CacheHolder();
}
public sta
浏览 0提问于2016-11-25得票数 3
如果我有一个哈希图和这个方法：
private Map<String, String> m = new HashMap<>();
private void add(String key, String value) {
String val = m.get(key);
if (val == null) {
m.put(key, value);
}
}
如果我有两个线程A和B使用相同的键和值调用方法，A和B可能都会看到键不在map中，因此可能会同时写入map。但是，写入顺序(A在B之前或B在A之前)不应影响结果，因为它们都写入相同
浏览 19提问于2021-03-02得票数 2
我有以下代码：
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
1.
我有多个线程在更新一个ConcurrentHashMap。每个线程根据键向映射项的值追加一个整数列表。没有任何线程的移除操作。
这里的要点是，我希望尽可能减少锁定和同步的范围。
我看到computeIf.()方法的doc说“其他线程在此地图上的一些尝试更新操作可能会在计算过程中被阻止”，这并不令人鼓舞。另一方面，当我查看它的源代码时，我没有观察到它在整个地图上锁定/同步的位置。
因此，我想知道使用.()的理论性能的比较，以及以下国产的‘方法2’。
2.
此外，我觉得我在这里描述的问题可能是您可以在ConcurrentHashMap上执行的最简化的check集(或者一般是“复合”)操作之一
浏览 5提问于2016-04-14得票数 3
回答已采纳
4回答
我需要创建像这样的散列图：
Map<String, List<Integer>>
我用了两个线程。
这里是输出地图的一个示例：
---------------------
| xxx | a b c d |
| yyy | a' b' c' d' |
| zzz | A B C D |
---------------------
这两个线程都有助于创建条目；因此，例如，线程1具有以下要存储的数据集：
-----------------------------------
| 1 | (xxx,a) (yyy,a'
浏览 14提问于2016-12-23得票数 2
回答已采纳
2回答
并发的java双向映射
、、、
我正在为文本处理编写代码，如果我首先将字符串转换为整数，那么的速度要快得多。为了做到这一点，我创建了一个Dictionary类，每当我看到一个新字符串时，我都会给它一个索引，并保存两个映射，一个是从字符串到int，另一个是从int到字符串，这样我就可以轻松地查找两种方式。下面是代码：
class Dictionary {
private Map<String, Integer> map;
private Map<Integer, String> reverse_map;
private int nextIndex;
public Dic
浏览 1提问于2012-07-13得票数 1
回答已采纳
单检查成语可用于实现线程安全延迟init，与重复检查相比，多个并发inits可能会浪费一些计算时间。它是
单选成语
private volatile FieldType field;
FieldType getField() {
FieldType result = field;
if (result == null) {
field = result = computeFieldValue();
}
return result;
}
在这里，我们需要易失性field来避免将部分初始化的对象传递给另一个线程，即--赋值(写)隐式地执行必要的同步。
我想实现一个参数化的懒
浏览 5提问于2015-08-11得票数 0
我不明白为什么FindBug会抱怨这个代码
Foo obj = map.get(id);
if(obj == null) {
obj = new Foo();
map.put(id, obj);
}
obj.add(someObject);
第二版
Foo tmp = new Foo();
obj = map.putIfAbsent(id, tmp);
if (obj == null)
obj = tmp
obj.add(someObject);
如果我执行第二个版本，则每次都必须创建Foo对象。
Foo obj = map.get(id);
if(obj ==
浏览 8提问于2015-04-15得票数 0
回答已采纳
1回答
在服务器上进行HTTP调用后，我必须解析响应。如果响应不成功，那么尝试另一个服务器，否则解析成功的响应，并填充两个ConcurrentHashMap并退出for循环。并且所有的服务器都将以相同的格式给出相同的确切响应。
下面是我的单例类，它在第一次调用ProcConfig的构造函数时，调用loadConfig()方法来初始化所有内容，然后检查addressToIdMapping映射中是否有一个条目。如果它不在那里，那么它会抛出异常。之后，它会启动一个后台线程，每隔30分钟就会调用loadConfig()方法来更新addressToIdMapping和processToTcpMapping地图。
浏览 4提问于2017-02-20得票数 0
回答已采纳
2回答
我如何安全地将元素放入
ConcurrentMap <String, Set<Integer>> cmap = new ConcurrentMap<String, Set<Integer>>();
我在并行地图上操作如下：
如果一个键不存在:放入一个带有字符串和全新Set<Integer>的条目
如果存在:向该键的Set<Integer>值添加特定的Set<Integer>。
浏览 0提问于2018-03-15得票数 1
ConcurrentHashMap在Java中的用途是什么？它的好处是什么？它怎麽工作?示例代码也会很有用。
浏览 8提问于2010-05-15得票数 61
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
