ConcurrentMap.putIfAbsent(key,value) 用法讨论

先看一段代码：

public class Locale {
	private final static Map<String, Locale> map = new HashMap<String,Locale>();
	public static Locale getInstance(String language, String country,
			String variant) {
		//...
		String key = some_string;
		Locale locale = map.get(key);
		if (locale == null) {
			locale = new Locale(language, country, variant);
			map.put(key, locale);
		}
		return locale;
	}
	// ....
}

 

 这段代码要做的事情是：

 

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：

if (locale == null) {
    locale = new Locale(language, country, variant);
    map.put(key, locale);
}

 因为在某个线程做完 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 写的那样：

/**
     * If the specified key is not already associated
     * with a value, associate it with the given value.
     * This is equivalent to
     * <pre>
     *   if (!map.containsKey(key))
     *       return map.put(key, value);
     *   else
     *       return map.get(key);</pre>
     * except that the action is performed atomically.
     * .....
     */

所以可以使用该方法替代上面代码里的操作。但是，替代的时候很容易犯一个错误。请看下面的代码：

public class Locale implements Cloneable, Serializable {
    private final static ConcurrentMap<String, Locale> map = new ConcurrentHashMap<String, Locale>();
	public static Locale getInstance(String language, String country,
			String variant) {
		//...
		String key = some_string;
		Locale locale = map.get(key);
		if (locale == null) {
			locale = new Locale(language, country, variant);
			map.putIfAbsent(key, locale);
		}
		return locale;
	}
	// ....
}

 这段代码使用了 Map 的 concurrent 形式（ConcurrentMap、ConcurrentHashMap），并简单的使用了语句map.putIfAbsent(key, locale) 。这同样不能保证相同的 key 返回同一个 Locale 对象引用。

 

这里的错误出在忽视了 putIfAbsent 方法是有返回值的，并且返回值很重要。依旧看 javadoc：

   /**
     * @return  the previous value associated with the specified key, or
     *         <tt>null</tt> if there was no mapping for the key.
     *         (A <tt>null</tt> return can also indicate that the map
     *         previously associated <tt>null</tt> with the key,
     *         if the implementation supports null values.)
     */

“如果（调用该方法时）key-value 已经存在，则返回那个 value 值。如果调用时 map 里没有找到 key 的 mapping，返回一个 null 值”

 

所以，使用 putIfAbsent 方法时切记要对返回值进行判断。如下所示（java.util.Locale 类中的实现代码）：

public final class Locale implements Cloneable, Serializable {
    // cache to store singleton Locales
    private final static ConcurrentHashMap<String, Locale> cache = new ConcurrentHashMap<String, Locale>(32);
    static Locale getInstance(String language, String country, String variant) {
        if (language== null || country == null || variant == null) {
            throw new NullPointerException();
        }

	StringBuilder sb = new StringBuilder();
	sb.append(language).append('_').append(country).append('_').append(variant);
	String key = sb.toString();
	Locale locale = cache.get(key);
	if (locale == null) {
	    locale = new Locale(language, country, variant);
	    Locale l = cache.putIfAbsent(key, locale);
	    if (l != null) {
		locale = l;
	    }
	}
	return locale;
    }
	// ....
}

与前段代码相比，增加了对方法返回值的判断：

        Locale l = cache.putIfAbsent(key, locale);  
        if (l != null) {  
            locale = l;  
        }  

 

这样可以保证并发情况下代码行为的准确性。

 

-------------------------------------------------

本文写的内容源于今天阅读 java.util.DateFormat 源码时碰到的一个用法，更准确的说，这个用法出现在 java SE 6 的 java.util.Locale 类的 getInstance(String language, String country, String variant) 方法实现部分。

 

加之前阵子刚看过 FindBugs 的某个 ppt [2]，ppt 上举了几个 Java 程序员容易犯错的代码写法的例子，其中一个就是忽视ConcurrentMap.putIfAbsent 方法返回值的情况。

 

最后，借用 ppt 上给的关于这个错误的 lessons（经验教训）：

 

• Concurrency is tricky
• putIfAbsent is tricky to use correctly
• engineers at Google got it wrong more than 10% of the time
• Unless you need to ensure a single value, just use get followed by put if not found
• If you need to ensure a single unique value shared by all threads, use putIfAbsent and Check return value

-------------------------------------------

参考：

[1] Java Concurrency in Practice. by Brian Goetz, Tim Peierls, Joshua Bloch el.

[2] Defective Java Code: Mistakes That Matter. by William Pugh

 

 

 

 

 

评论

2 楼 liwei985 2017-02-25  

xiaoy81 写道

putIfAbsent是原子性的，多线程去操作Locale l = cache.putIfAbsent(key, locale)的时候只有第一个能设置成功，其他线程返回的都是第一个设置成功的那个值，不需要判断返回值问题，别误人子弟

putIfAbsent 是原子性的，但是楼主说的是“取” 和 “存” 两个操作的复合操作，看懂没有？

1 楼 xiaoy81 2017-01-22  

putIfAbsent是原子性的，多线程去操作Locale l = cache.putIfAbsent(key, locale)的时候只有第一个能设置成功，其他线程返回的都是第一个设置成功的那个值，不需要判断返回值问题，别误人子弟