concurrenthashmap 2 适用场景
来源:互联网 发布:人工智能社区 编辑:程序博客网 时间:2024/05/29 17:21
ConcurrentHashMap通常只被看做并发效率更高的Map,用来替换其他线程安全的Map容器,比如Hashtable和Collections.synchronizedMap。实际上,线程安全的容器,特别是Map,应用场景没有想象中的多,很多情况下一个业务会涉及容器的多个操作,即复合操作,并发执行时,线程安全的容器只能保证自身的数据不被破坏,但无法保证业务的行为是否正确。
举个例子:统计文本中单词出现的次数,把单词出现的次数记录到一个Map中,代码如下:
1
private
final
Map<String, Long> wordCounts =
new
ConcurrentHashMap<>();
2
3
public
long
increase(String word) {
4
Long oldValue = wordCounts.get(word);
5
Long newValue = (oldValue ==
null
) ? 1L : oldValue +
1
;
6
wordCounts.put(word, newValue);
7
return
newValue;
8
}
如果多个线程并发调用这个increase()方法,increase()的实现就是错误的,因为多个线程用相同的word调用时,很可能会覆盖相互的结果,造成记录的次数比实际出现的次数少。
除了用锁解决这个问题,另外一个选择是使用ConcurrentMap接口定义的方法:
1
public
interface
ConcurrentMap<K, V>
extends
Map<K, V> {
2
V putIfAbsent(K key, V value);
3
boolean
remove(Object key, Object value);
4
boolean
replace(K key, V oldValue, V newValue);
5
V replace(K key, V value);
6
}
这是个被很多人忽略的接口,也经常见有人错误地使用这个接口。ConcurrentMap接口定义了几个基于 CAS(Compare and Set)操作,很简单,但非常有用,下面的代码用ConcurrentMap解决上面问题:
01
private
final
ConcurrentMap<String, Long> wordCounts =
new
ConcurrentHashMap<>();
02
03
public
long
increase(String word) {
04
Long oldValue, newValue;
05
while
(
true
) {
06
oldValue = wordCounts.get(word);
07
if
(oldValue ==
null
) {
08
// Add the word firstly, initial the value as 1
09
newValue = 1L;
10
if
(wordCounts.putIfAbsent(word, newValue) ==
null
) {
11
break
;
12
}
13
}
else
{
14
newValue = oldValue +
1
;
15
if
(wordCounts.replace(word, oldValue, newValue)) {
16
break
;
17
}
18
}
19
}
20
return
newValue;
21
}
代码有点复杂,主要因为ConcurrentMap中不能保存value为null的值,所以得同时处理word不存在和已存在两种情况。
上面的实现每次调用都会涉及Long对象的拆箱和装箱操作,很明显,更好的实现方式是采用AtomicLong,下面是采用AtomicLong后的代码:
01
private
final
ConcurrentMap<String, AtomicLong> wordCounts =
new
ConcurrentHashMap<>();
02
03
public
long
increase(String word) {
04
AtomicLong number = wordCounts.get(word);
05
if
(number ==
null
) {
06
AtomicLong newNumber =
new
AtomicLong(
0
);
07
number = wordCounts.putIfAbsent(word, newNumber);
08
if
(number ==
null
) {
09
number = newNumber;
10
}
11
}
12
return
number.incrementAndGet();
13
}
这个实现仍然有一处需要说明的地方,如果多个线程同时增加一个目前还不存在的词,那么很可能会产生多个newNumber对象,但最终只有一个newNumber有用,其他的都会被扔掉。对于这个应用,这不算问题,创建AtomicLong的成本不高,而且只在添加不存在词是出现。但换个场景,比如缓存,那么这很可能就是问题了,因为缓存中的对象获取成本一般都比较高,而且通常缓存都会经常失效,那么避免重复创建对象就有价值了。下面的代码演示了怎么处理这种情况:
01
private
final
ConcurrentMap<String, Future<ExpensiveObj>> cache =
new
ConcurrentHashMap<>();
02
03
public
ExpensiveObj get(
final
String key) {
04
Future<ExpensiveObj> future = cache.get(key);
05
if
(future ==
null
) {
06
Callable<ExpensiveObj> callable =
new
Callable<ExpensiveObj>() {
07
@Override
08
public
ExpensiveObj call()
throws
Exception {
09
return
new
ExpensiveObj(key);
10
}
11
};
12
FutureTask<ExpensiveObj> task =
new
FutureTask<>(callable);
13
14
future = cache.putIfAbsent(key, task);
15
if
(future ==
null
) {
16
future = task;
17
task.run();
18
}
19
}
20
21
try
{
22
return
future.get();
23
}
catch
(Exception e) {
24
cache.remove(key);
25
throw
new
RuntimeException(e);
26
}
27
}
解决方法其实就是用一个Proxy对象来包装真正的对象,跟常见的lazy load原理类似;使用FutureTask主要是为了保证同步,避免一个Proxy创建多个对象。注意,上面代码里的异常处理是不准确的。
最后再补充一下,如果真要实现前面说的统计单词次数功能,最合适的方法是Guava包中AtomicLongMap;一般使用ConcurrentHashMap,也尽量使用Guava中的MapMaker或cache实现。
- concurrenthashmap 2 适用场景
- ConcurrentHashMap的使用场景
- Ajax适用场景
- Ajax适用场景
- Ajax适用场景
- Nodejs的适用场景
- nodejs 适用场景
- mysql适用场景
- Ajax适用场景
- Ajax不适用场景
- 美图秀秀各插件适用场景
- Volley适用场景
- mongodb不适用场景
- Ajax适用场景
- Protobuf适用场景
- Hive的适用场景
- redis适用场景
- 工作流适用场景
- 0710编程之美二进制树中1的个数 三种解法
- [PAT-甲级]1019.General Palindromic Number
- Mybatis 源码解析 -插件模块
- Golang教程:(九)循环语句
- [PAT-甲级]1020.Tree Traversals
- concurrenthashmap 2 适用场景
- vsftpd服务安装/启动/连接/退出
- 用faster rcnn 训练其他数据集
- Android Studio 关联源码
- QT之QML控件篇
- 水题 第三站 排列2
- 【utils】基于jackson的解析转换JsonUtil
- C/C++ 引用介绍
- Android面试题记录二