我有一个并发HashMap实例，一些线程向其添加条目。值是整数。
同时，其他线程希望检索映射中所有值的总和。我希望这些线程看到一致的值。但是，不需要总是看到最新的值。
以下代码线程是否安全？
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class MyClass {
private Map<Integer, Integer> values = new ConcurrentHashMap<>();
public void addValue(Integer key, int value){
values.put(key, value);
}
public long sumOfValues(){
return values
.values()
.stream()
.mapToInt(Integer::intValue)
.sum();
}
}
求和操作会在一组一致的值上计算吗？
发生求和操作时，对put（）的调用会被阻止吗？
当然，我可以自己同步访问，甚至拆分读锁和写锁以允许并发读访问和同步写访问，但我很好奇在使用并发HashMap作为集合实现时是否有必要。
留档说明了ConCurrentHashMap的keySet（）和entrySet（）：视图的迭代器和拆分器是弱一致的。
弱一致的特征为
所以…
以下代码线程是否安全？
是的，从狭义上说，缺少ConloctModificationException或HashMap的内部不一致。
求和操作会在一组一致的值上计算吗？
弱一致集上
发生求和操作时，对put（）的调用会被阻止吗？
不
ConCurrentHashMap的要点是条目尽可能相互独立。整个地图没有一致的视图。事实上，即使size也不会返回非常有用的值。
如果您需要同时查询总和，一种解决方案是编写一个包装类来维护映射的状态和总和，使用LongAdder以原子方式维护总和。
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.LongAdder;
public class MapSum {
private final ConcurrentMap<Integer, Integer> map = new ConcurrentHashMap<>();
private final LongAdder sum = new LongAdder();
public Integer get(Integer k) {
return map.get(k);
}
public Integer put(Integer k, Integer v) {
Integer[] out = new Integer[1];
map.compute(k, (_k, old) -> {
out[0] = old;
// cast to long to avoid overflow
sum.add((long) v - (old != null ? old : 0));
return v;
});
return out[0];
}
public Integer remove(Integer k) {
Integer[] out = new Integer[1];
map.compute(k, (_k, old) -> {
out[0] = old;
// cast to long to avoid overflow; -Integer.MIN_VALUE == Integer.MIN_VALUE
if(old != null) { sum.add(- (long) old); }
return null;
});
return out[0];
}
public long sum() {
return sum.sum();
}
}
这具有在O（1）而不是O（n）时间查询总和的额外好处。如果您愿意，您可以添加更多Map方法，甚至实现Map
