在使用ConcurrentMap的putIfAbsent之前是否应该检查地图是否包含Key

我一直在使用Java的ConcurrentMap作为可从多个线程使用的地图。putIfAbsent是一种很棒的方法，比使用标准映射操作更容易读/写。我有一些看起来像这样的代码：

ConcurrentMap<String, Set<X>> map = new ConcurrentHashMap<String, Set<X>>();

// ...

map.putIfAbsent(name, new HashSet<X>());
map.get(name).add(Y);

在可读性方面，这很棒，但是每次都需要创建一个新的HashSet，即使它已经在地图中了。我可以这样写：

if (!map.containsKey(name)) {
    map.putIfAbsent(name, new HashSet<X>());
}
map.get(name).add(Y);

进行此更改后，它将失去一些可读性，但无需每次都创建HashSet。在这种情况下哪个更好？我倾向于第一个，因为它更具可读性。第二个将表现更好，并且可能更正确。也许有比这两种方法更好的方法。

以这种方式使用putIfAbsent的最佳实践是什么？

并发很难。如果您要为并发映射而不是直接锁定而烦恼，那么不妨这样做。确实，不要进行不必要的查找。

Set<X> set = map.get(name);
if (set == null) {
    final Set<X> value = new HashSet<X>();
    set = map.putIfAbsent(name, value);
    if (set == null) {
        set = value;
    }
}

（通常的stackoverflow免责声明：超出我的头脑。未经测试。未经编译。等等。）

更新： 1.8已向中添加了computeIfAbsent默认方法ConcurrentMap（Map这很有趣，因为该实现对错误ConcurrentMap）。（并且1.7添加了“钻石算子” <>。）

Set<X> set = map.computeIfAbsent(name, n -> new HashSet<>());

（请注意，您应对HashSet。中包含的的任何操作的线程安全负责ConcurrentMap。）

就ConcurrentMap的API使用而言，Tom的答案是正确的。避免使用putIfAbsent的另一种方法是使用GoogleCollections / Guava MapMaker中的计算图，后者使用提供的函数自动填充值并为您处理所有线程安全性。实际上，每个键仅创建一个值，如果create函数昂贵，则其他要求获取同一键的线程将阻塞，直到该值可用为止。

从Guava 11中进行编辑，MapMaker已弃用，并由Cache / LocalCache / CacheBuilder替换。它的用法有些复杂，但基本上是同构的。

您可以使用MutableMap.getIfAbsentPut(K, Function0<? extends V>)从Eclipse的集合（原GS集合）。

与先调用get()，执行空检查然后再调用的优点putIfAbsent()是，我们只计算一次键的hashCode，然后一次在哈希表中找到正确的位置。在类似org.eclipse.collections.impl.map.mutable.ConcurrentHashMap的ConcurrentMaps中，的实现getIfAbsentPut()也是线程安全的和原子的。

import org.eclipse.collections.impl.map.mutable.ConcurrentHashMap;
...
ConcurrentHashMap<String, MyObject> map = new ConcurrentHashMap<>();
map.getIfAbsentPut("key", () -> someExpensiveComputation());

实施 org.eclipse.collections.impl.map.mutable.ConcurrentHashMap真正是非阻塞的。尽管已尽一切努力避免不必要地调用工厂函数，但仍有可能在争用期间多次调用它。

这个事实使它与Java 8有所不同ConcurrentHashMap.computeIfAbsent(K, Function<? super K,? extends V>)。此方法的Javadoc指出：

整个方法调用是原子执行的，因此每个键最多可应用一次该功能。在计算进行过程中，可能会阻止其他线程对此映射进行的某些尝试的更新操作，因此计算应简短而又...

注意：我是Eclipse Collections的提交者。

通过为每个线程保留一个预先初始化的值，您可以改善可接受的答案：

Set<X> initial = new HashSet<X>();
...
Set<X> set = map.putIfAbsent(name, initial);
if (set == null) {
    set = initial;
    initial = new HashSet<X>();
}
set.add(Y);

我最近将此用于AtomicInteger映射值，而不是Set。

在5年多的时间里，我无法相信没有人提到或发布过使用ThreadLocal解决此问题的解决方案。并且此页面上的一些解决方案不是线程安全的，只是草率的。

针对此特定问题使用ThreadLocals不仅被视为并发最佳实践，而且还可以最大程度地减少在此期间的垃圾/对象创建线程争用。而且，它是非常干净的代码。

例如：

private final ThreadLocal<HashSet<X>> 
  threadCache = new ThreadLocal<HashSet<X>>() {
      @Override
      protected
      HashSet<X> initialValue() {
          return new HashSet<X>();
      }
  };


private final ConcurrentMap<String, Set<X>> 
  map = new ConcurrentHashMap<String, Set<X>>();

以及实际的逻辑...

// minimize object creation during thread contention
final Set<X> cached = threadCache.get();

Set<X> data = map.putIfAbsent("foo", cached);
if (data == null) {
    // reset the cached value in the ThreadLocal
    listCache.set(new HashSet<X>());
    data = cached;
}

// make sure that the access to the set is thread safe
synchronized(data) {
    data.add(object);
}

我的一般近似：

public class ConcurrentHashMapWithInit<K, V> extends ConcurrentHashMap<K, V> {
  private static final long serialVersionUID = 42L;

  public V initIfAbsent(final K key) {
    V value = get(key);
    if (value == null) {
      value = initialValue();
      final V x = putIfAbsent(key, value);
      value = (x != null) ? x : value;
    }
    return value;
  }

  protected V initialValue() {
    return null;
  }
}

并作为使用示例：

public static void main(final String[] args) throws Throwable {
  ConcurrentHashMapWithInit<String, HashSet<String>> map = 
        new ConcurrentHashMapWithInit<String, HashSet<String>>() {
    private static final long serialVersionUID = 42L;

    @Override
    protected HashSet<String> initialValue() {
      return new HashSet<String>();
    }
  };
  map.initIfAbsent("s1").add("chao");
  map.initIfAbsent("s2").add("bye");
  System.out.println(map.toString());
}