从java.util.Locale 源码理解 ConcurrentHashMap 的 putIfAbsent方法

本文通过分析Java中的`java.util.Locale`类,探讨了`ConcurrentHashMap`的`putIfAbsent`方法如何实现线程安全。`putIfAbsent`在并发环境中确保了原子性,避免了多个线程同时插入相同键的情况,提高了效率。通过源码解析,展示了在`Locale`类中使用`ConcurrentHashMap`避免了同步锁,提升了性能。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

本文根据 文章  http://blog.youkuaiyun.com/exceptional_derek/article/details/40384659 整理。


ConcurrentHashMap 是线程安全且较高效的Map结构。

下面分析一下 ConcurrentHashMap 为什么是线程安全的。

1、 putIfAbsent 方法

V putIfAbsent(K key,V value) : 如果指定键已经不再与某个值相关联,则将它与给定值关联。

putIfAbsent()方法用于在map中进行添加。这个方法以要添加到ConcurrentMap中的键的值为参数,就像普通的put()方法,但是只有在map不包含这个键时,才能将键加入到map中。如果map已经包含这个键,那么这个键的现有值就会保留。putIfAbsent()方法是原子的。等价于下面的代码(除了原子地执行此操作之外):

[java]  view plain  copy
  1. if(!map.containsKey(key))  
  2.     return map.put(key,value);  
  3. else  
  4.     return map.get(key)  

先看一段代码:

Java代码   收藏代码
  1. public class Locale {  
  2.     private final static Map<String, Locale> map = new HashMap<String,Locale>();  
  3.     public static Locale getInstance(String language, String country,  
  4.             String variant) {  
  5.         //...  
  6.         String key = some_string;  
  7.         Locale locale = map.get(key);  
  8.         if (locale == null) {  
  9.             locale = new Locale(language, country, variant);  
  10.             map.put(key, locale);  
  11.         }  
  12.         return locale;  
  13.     }  
  14.     // ....  
  15. }  

 

 这段代码要做的事情是:

 

  1. 调用 map.get(key) 方法,判断 map 里面是否有该 key 对应的 value (Locale 对象)。
  2. 如果返回 null,表示 map 里面没有要查找的 key-value mapping。new 一个 Locale 对象,并把 new 出来的这个对象与 key 一起放入 map。
  3. 最后返回新创建的 Locale 对象
我们期望每次调用 getInstance 方法时要保证相同的 key 返回同一个 Local 对象引用。那么,单看第一段代码,请问它能实现这个期望么?
 
答案是:在单线程环境下可以满足要求,但是在多线程环境下会存在线程安全性问题,即不能保证在并发的情况相同的 key 返回同一个 Local 对象引用。
 
这是因为在上面的代码里存在一个习惯被称为 put-if-absent 的操作 [1],而这个操作存在一个 race condition:
Java代码   收藏代码
  1. if (locale == null) {  
  2.     locale = new Locale(language, country, variant);  
  3.     map.put(key, locale);  
  4. }  
 因为在某个线程做完 locale == null 的判断到真正向 map 里面 put 值这段时间,其他线程可能已经往 map 做了 put 操作,这样再做 put 操作时,同一个 key 对应的 locale 对象被覆盖掉,最终 getInstance 方法返回的同一个 key 的 locale 引用就会出现不一致的情形。所以对 Map 的 put-if-absent 操作是不安全的(thread safty)。
 
为了解决这个问题,java 5.0 引入了 ConcurrentMap 接口,在这个接口里面 put-if-absent 操作以原子性方法 putIfAbsent(K key, V value) 的形式存在。正如 javadoc 写的那样:
Java代码   收藏代码
  1. /** 
  2.      * If the specified key is not already associated 
  3.      * with a value, associate it with the given value. 
  4.      * This is equivalent to 
  5.      * <pre> 
  6.      *   if (!map.containsKey(key)) 
  7.      *       return map.put(key, value); 
  8.      *   else 
  9.      *       return map.get(key);</pre> 
  10.      * except that the action is performed atomically. 
  11.      * ..... 
  12.      */  
所以可以使用该方法替代上面代码里的操作。但是,替代的时候很容易犯一个错误。请看下面的代码:
Java代码   收藏代码
  1. public class Locale implements Cloneable, Serializable {  
  2.     private final static ConcurrentMap<String, Locale> map = new ConcurrentHashMap<String, Locale>();  
  3.     public static Locale getInstance(String language, String country,  
  4.             String variant) {  
  5.         //...  
  6.         String key = some_string;  
  7.         Locale locale = map.get(key);  
  8.         if (locale == null) {  
  9.             locale = new Locale(language, country, variant);  
  10.             map.putIfAbsent(key, locale);  
  11.         }  
  12.         return locale;  
  13.     }  
  14.     // ....  
  15. }  
 这段代码使用了 Map 的 concurrent 形式(ConcurrentMap、ConcurrentHashMap),并简单的使用了语句map.putIfAbsent(key, locale) 。这同样不能保证相同的 key 返回同一个 Locale 对象引用。
 
这里的错误出在忽视了 putIfAbsent 方法是有返回值的,并且返回值很重要。依旧看 javadoc:
Java代码   收藏代码
  1. /** 
  2.   * @return  the previous value associated with the specified key, or 
  3.   *         <tt>null</tt> if there was no mapping for the key. 
  4.   *         (A <tt>null</tt> return can also indicate that the map 
  5.   *         previously associated <tt>null</tt> with the key, 
  6.   *         if the implementation supports null values.) 
  7.   */  
“如果(调用该方法时)key-value 已经存在,则返回那个 value 值。如果调用时 map 里没有找到 key 的 mapping,返回一个 null 值”
 
所以,使用 putIfAbsent 方法时切记要对返回值进行判断。如下所示(java.util.Locale 类中的实现代码):
Java代码   收藏代码
  1. public final class Locale implements Cloneable, Serializable {  
  2.     // cache to store singleton Locales  
  3.     private final static ConcurrentHashMap<String, Locale> cache = new ConcurrentHashMap<String, Locale>(32);  
  4.     static Locale getInstance(String language, String country, String variant) {  
  5.         if (language== null || country == null || variant == null) {  
  6.             throw new NullPointerException();  
  7.         }  
  8.   
  9.     StringBuilder sb = new StringBuilder();  
  10.     sb.append(language).append('_').append(country).append('_').append(variant);  
  11.     String key = sb.toString();  
  12.     Locale locale = cache.get(key);  
  13.     if (locale == null) {  
  14.         locale = new Locale(language, country, variant);  
  15.         Locale l = cache.putIfAbsent(key, locale);  
  16.         if (l != null) {  
  17.         locale = l;  
  18.         }  
  19.     }  
  20.     return locale;  
  21.     }  
  22.     // ....  
  23. }  
与前段代码相比,增加了对方法返回值的判断:
Java代码   收藏代码
  1. Locale l = cache.putIfAbsent(key, locale);    
  2. if (l != null) {    
  3.     locale = l;    
  4. }    
 
这样可以保证并发情况下代码行为的准确性。

像putIfAbsent()方法一样,重载后的remove()方法有两个参数:键和值。在调用时,只有当键映射到指定的值时才从map中删除这个键。如果不匹配,那么就不删除这个键,并返回false。如果值匹配键的当前映射内容,那么就删除这个键,这个方法是原子性的。这种操作的等价源代码(除了原子地执行此操作之外):
[java]  view plain  copy
  1. if(map.containsKey(key) && map.get(key).equals(value)){  
  2.     map.remove(key);  
  3.     return true;  
  4. }else return false;  
总之,ConcurrentMap中定义的方法是原子性的。

### 关于 `ConcurrentHashMap` 引发的 `NullPointerException` 在 Java 中,当使用 `ConcurrentHashMap` 的过程中发生 `NullPointerException` 时,通常是因为尝试访问或操作一个为 `null` 的键或值。以下是针对该问题的具体分析和解决方案。 #### 错误原因 根据提供的错误日志,可以发现以下几点: - 当调用 `ConcurrentHashMap.get()` 方法时,如果传入的参数为 `null` 或者内部实现逻辑中存在未初始化的对象,则会抛出 `NullPointerException`[^2]。 - 类似的情况也可能发生在其他方法上,比如 `containsKey()` 和 `remove()` 等[^1]。 这些异常表明,在某些情况下,程序可能试图对尚未正确初始化或者已经移除的数据结构执行操作。 #### 解决方案 为了防止此类异常的发生,可以从以下几个方面入手改进代码: 1. **验证输入数据的有效性** 在向 `ConcurrentHashMap` 添加新条目之前以及每次读取前都应确认其合法性。例如: ```java if (key != null && value != null) { map.put(key, value); } ``` 2. **同步处理多线程环境下的并发修改** 虽然 `ConcurrentHashMap` 已经具备一定的线程安全性,但在极端条件下仍需额外注意。可以通过显式的锁机制来进一步保障一致性。例如: ```java synchronized(map) { Object result = map.get(someKey); // 进一步业务逻辑... } ``` 3. **捕获潜在的运行期错误并记录日志** 使用 try-catch 块包裹可能会出现问题的部分,并及时打印堆栈信息以便后续排查。如下所示: ```java try { Object obj = map.get(maybeNullKey); } catch (NullPointerException e) { System.err.println("Caught NPE while accessing map."); e.printStackTrace(); } ``` 4. **升级 JDK 版本** 如果当前使用的 JDK 较旧(如低于 8),建议考虑更新至最新稳定版本。因为较新的版本往往修复了许多已知缺陷并且性能更优[^3]。 5. **参考成功案例调整策略** 可借鉴他人分享的成功经验来进行针对性优化。例如有开发者提到过一种经过实践检验有效的办法能够彻底消除这类异常情况[^4]。 通过上述措施可有效降低甚至完全规避由 `ConcurrentHashMap` 所引起的 `NullPointerException` 风险。 ```java // 示例:综合运用多种手段预防NPE public class SafeConcurrentHashMap<K,V> extends ConcurrentHashMap<K,V> { @Override public V put(K key, V value){ if(null == key || null ==value ){ throw new IllegalArgumentException("Neither Key nor Value can be Null"); } return super.put(key,value); } @Override public boolean containsKey(Object key){ if(null==key){ return false; } return super.containsKey(key); } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值