语法使用
ConcurrentHashMap
案例：计数器
统计文本中单词出现的次数，把单词出现的次数记录到一个 Map 中，代码如下：
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 接口定义了几个基于 CAS（Compare and Set）操作，很简单，但非常有用，下面的代码用 ConcurrentMap 解决上面问题：
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;
}
值得一提的是，如果这里没有用 replace，那么同样会存在问题。上面的实现每次调用都会涉及 Long 对象的拆箱和装箱操作，很明显，更好的实现方式是采用 AtomicLong，下面是采用 AtomicLong 后的代码：
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 的成本不高，而且只在添加不存在词是出现。但换个场景，比如缓存，那么这很可能就是问题了，因为缓存中的对象获取成本一般都比较高，而且通常缓存都会经常失效，那么避免重复创建对象就有价值了。下面的代码演示了怎么处理这种情况：
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 实现。