ConcurrentHashMap使用示例

ConcurrentHashMap使用示例

发表于2年前(2013-07-12 19:05)   阅读（3660） | 评论（0） 25人收藏此文章, 我要收藏

赞5

如何快速提高你的薪资？-实力拍“跳槽吧兄弟”梦想活动即将开启

Java

ConcurrentHashMap通常只被看做并发效率更高的Map，用来替换其他线程安全的Map容器，比如Hashtable和Collections.synchronizedMap。实际上，线程安全的容器，特别是Map，应用场景没有想象中的多，很多情况下一个业务会涉及容器的多个操作，即复合操作，并发执行时，线程安全的容器只能保证自身的数据不被破坏，但无法保证业务的行为是否正确。

举个例子：统计文本中单词出现的次数，把单词出现的次数记录到一个Map中，代码如下：

?

1 2 3 4 5 6 7 8

private final Map<String, Long> wordCounts = new ConcurrentHashMap<>();   public long increase(String word) {     Long oldValue = wordCounts.get(word);     Long newValue = (oldValue == null) ? 1L : oldValue + 1;     wordCounts.put(word, newValue);     return newValue; }

如果多个线程并发调用这个increase()方法，increase()的实现就是错误的，因为多个线程用相同的word调用时，很可能会覆盖相互的结果，造成记录的次数比实际出现的次数少。

除了用锁解决这个问题，另外一个选择是使用ConcurrentMap接口定义的方法：

?

1 2 3 4 5 6

public interface ConcurrentMap<K, V> extends Map<K, V> {     V putIfAbsent(K key, V value);     boolean remove(Object key, Object value);     boolean replace(K key, V oldValue, V newValue);     V replace(K key, V value); }

这是个被很多人忽略的接口，也经常见有人错误地使用这个接口。ConcurrentMap接口定义了几个基于 CAS（Compare and Set）操作，很简单，但非常有用，下面的代码用ConcurrentMap解决上面问题：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

private final ConcurrentMap<String, Long> wordCounts = new ConcurrentHashMap<>();   public long increase(String word) {     Long oldValue, newValue;     while (true) {         oldValue = wordCounts.get(word);         if (oldValue == null) {             // Add the word firstly, initial the value as 1             newValue = 1L;             if (wordCounts.putIfAbsent(word, newValue) == null) {                 break;             }         } else {             newValue = oldValue + 1;             if (wordCounts.replace(word, oldValue, newValue)) {                 break;             }         }     }     return newValue; }

代码有点复杂，主要因为ConcurrentMap中不能保存value为null的值，所以得同时处理word不存在和已存在两种情况。

上面的实现每次调用都会涉及Long对象的拆箱和装箱操作，很明显，更好的实现方式是采用AtomicLong，下面是采用AtomicLong后的代码：

?

1 2 3 4 5 6 7 8 9 10 11 12 13

private final ConcurrentMap<String, AtomicLong> wordCounts = new ConcurrentHashMap<>();   public long increase(String word) {     AtomicLong number = wordCounts.get(word);     if (number == null) {         AtomicLong newNumber = new AtomicLong(0);         number = wordCounts.putIfAbsent(word, newNumber);         if (number == null) {             number = newNumber;         }     }     return number.incrementAndGet(); }

这个实现仍然有一处需要说明的地方，如果多个线程同时增加一个目前还不存在的词，那么很可能会产生多个newNumber对象，但最终只有一个newNumber有用，其他的都会被扔掉。对于这个应用，这不算问题，创建AtomicLong的成本不高，而且只在添加不存在词是出现。但换个场景，比如缓存，那么这很可能就是问题了，因为缓存中的对象获取成本一般都比较高，而且通常缓存都会经常失效，那么避免重复创建对象就有价值了。下面的代码演示了怎么处理这种情况：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

private final ConcurrentMap<String, Future<ExpensiveObj>> cache = new ConcurrentHashMap<>();   public ExpensiveObj get(final String key) {     Future<ExpensiveObj> future = cache.get(key);     if (future == null) {         Callable<ExpensiveObj> callable = new Callable<ExpensiveObj>() {             @Override             public ExpensiveObj call() throws Exception {                 return new ExpensiveObj(key);             }         };         FutureTask<ExpensiveObj> task = new FutureTask<>(callable);           future = cache.putIfAbsent(key, task);         if (future == null) {             future = task;             task.run();         }     }       try {         return future.get();     } catch (Exception e) {         cache.remove(key);         throw new RuntimeException(e);     } }

解决方法其实就是用一个Proxy对象来包装真正的对象，跟常见的lazy load原理类似；使用FutureTask主要是为了保证同步，避免一个Proxy创建多个对象。注意，上面代码里的异常处理是不准确的。

最后再补充一下，如果真要实现前面说的统计单词次数功能，最合适的方法是Guava包中AtomicLongMap；一般使用ConcurrentHashMap，也尽量使用Guava中的MapMaker或cache实现。