如何用computeIfAbsent效率实现Map putIfAbsent语义？

Question

考虑以下代码：

ConcurrentHashMap<String, Value> map = new ConcurrentHashMap<>();

boolean foo(String key) {
    Value value = map.get(key);
    if (value == null) {
        value = map.putIfAbsent(key, new Value());
        if (value == null) {
            // do some stuff
            return true;
        }
    }
    // do some other stuff
    return false;
 }
    

假设foo() 被多个线程同时调用。还假设调用new Value() 很昂贵。代码很冗长，仍然会导致创建冗余的Value 对象。上述逻辑能否以保证不创建冗余Value 对象的方式实现（即最多调用一次new Value()）？我正在寻找一个干净的实现——无需显式获取锁的最少代码。

computeIfAbsent 可能是一个不错的选择，但是它的返回语义不符合所需的逻辑。

Answer 1

完成这项工作的一些最小代码：

boolean foo(String key) {
    AtomicBoolean flag = new AtomicBoolean();
    Value value = map.computeIfAbsent(key, k -> {flag.set(true); return new Value();});
    if (flag.get()) {
        // do some stuff
    } else {
        // do some other stuff
    }
    return flag.get();
}

Answer 2

一种解决方案是在地图中存储Future<Value> 而不是Value：

ConcurrentHashMap<String, Future<Value>> map = new ConcurrentHashMap<>();

boolean foo(String key) {
    Future<Value> value = map.get(key);
    if (value == null) {
        value = map.putIfAbsent(key, new FutureTask<Value>(() -> new Value()));
        if (value == null) {
            // do some stuff
            return true;
        }
    }
    // do some other stuff
    return false;
}

您可以通过调用value.get() 访问基础值，这将阻塞直到计算完成。

有可能会创建多个 FutureTask，但只有一个会到达地图，并且只会完成一次 new Value() 的计算。

Answer 3

首先，让我们解决您不是原子行为的事实，并进行不必要的查找。两个线程可以同时通过第一个value == null 检查。现在不是真正的问题（除了将创建 2 个 Values，这很慢），但是如果有人在第二个 value == null 检查中添加 else 子句，则会等待发生错误。这样也更干净。

boolean foo(String key) {
    Value value = map.putIfAbsent(key, new Value());
    if (value == null) {
        // do some stuff
        return true;
    } 
    else {
       // do some other stuff
       return false;
    }
 }

现在让我们解决Value 创建速度慢的事实（听起来你在滥用构造函数，但无论如何）。

 boolean foo(String key) {
    final AtomicBoolean wasCreated = new AtomicBoolean(false);
    final Value value = map.computeIfAbsent(key, k -> {
        wasCreated.set(true);
        return new Value();
    });
    if (wasCreated.get()) {
        // do some stuff
        return true;
    } 
    else {
       // do some other stuff
       return false;
    }
 }

Answer 4

一种方法是使用本地状态并在computeIfAbsent的映射函数中更新它：

boolean foo(String key) {
    boolean[] b = { false };
    map.computeIfAbsent(key, k -> {
        // do some stuff
        b[0] = true;
        return new Value();
    });
    return b[0];
}

因为mappingFunction只有在key不存在的情况下才会运行，你可以保证重的new Value()只在必要的时候被调用并且返回值被设置为true只有当没有调用前的映射。

Answer 5

考虑您的方法foo（实际上是 putIfAbsent 的包装器）。

String key = "test";
if(foo(key)){
    //Positive Branch. 
} else{
    //Negative Branch.
}

现在，在多线程环境中，线程 A 调用并完成 foo 并添加一个新值。它正在沿着积极的分支。在它进入正分支之前，它被安排在以后。线程 B 调用并完成 foo，它继续执行并进入 Negative 分支。

Negative 分支在 Positive 分支之前执行，这在我看来是不想要的。在您的特定情况下，它可能没问题。 compute 可能是更好的替代品。

map.compute( key, ( k, old ) -> {
    if(old==null){
        Value v = new Value();
        //positive branch.
        return v;
    } else{
        //negative branch.
        return old;
    }
});

现在您将自动判断该值是否存在。