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

本文根据 文章  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中定义的方法是原子性的。