同步集合/列表的映射

Question

我想在“Map of Sets”集合上实现一个变体，该集合将被多个线程不断访问。我想知道我所做的同步是否足以保证不会出现任何问题。

所以给定以下代码，其中 Map、HashMap 和 Set 是 Java 实现，而 Key 和 Value 是一些任意对象：

public class MapOfSets {
    private Map<Key, Set<Value>> map;

    public MapOfLists() {
        map = Collections.synchronizedMap(new HashMap<Key, Set<Value>());
    }

    //adds value to the set mapped to key
    public void add(Key key, Value value) {
        Set<Value> old = map.get(key);

        //if no previous set exists on this key, create it and add value to it
        if(old == null) {
            old = new Set<Value>();
            old.add(value);
            map.put(old);
        }
        //otherwise simply insert the value to the existing set
        else {
            old.add(value);
        }
    }

    //similar to add
    public void remove(Key key, Value value) {...}

    //perform some operation on all elements in the set mapped to key
    public void foo(Key key) {
        Set<Value> set = map.get(key);

        for(Value v : set)
            v.bar();
    }
}

这里的想法是因为我已经同步了 Map 本身，所以 get() 和 put() 方法应该是原子的，对吧？所以应该不需要对 Map 或其中包含的 Sets 进行额外的同步。那么这会奏效吗？

或者，上述代码是否比另一种可能的同步解决方案更有优势：

public class MapOfSets {
    private Map<Key, Set<Value>> map;

    public MapOfLists() {
        map = new HashMap<Key, Set<Value>();
    }

    public synchronized void add(Key key, Value value) {
        Set<Value> old = map.get(key);

        //if no previous set exists on this key, create it and add value to it
        if(old == null) {
            old = new Set<Value>();
            old.add(value);
            map.put(old);
        }
        //otherwise simply insert the value to the existing set
        else {
            old.add(value);
        }
    }

    //similar to add
    public synchronized void remove(Key key, Value value) {...}

    //perform some operation on all elements in the set mapped to key
    public synchronized void foo(Key key) {
        Set<Value> set = map.get(key);

        for(Value v : set)
            v.bar();
    }
}

我不同步数据结构，而是同步所有可能的公共方法。那么哪些会起作用，哪个更好呢？

Answer 1

您发布的第一个实现不是线程安全的。考虑当两个具有相同key 的并发线程访问add 方法时会发生什么：

1. 线程 A 执行该方法的第 1 行，并获得 null 引用，因为不存在具有给定键的项目
2. 线程 B 执行该方法的第 1 行，并获得一个 null 引用，因为不存在具有给定键的项目 - 这将在 A 从第一次调用，因为地图是同步的
3. 线程 A 将 if 条件评估为 false
4. 线程 B 将 if 条件评估为 false

从那时起，两个线程将继续执行 if 语句的 true 分支，您将丢失两个 value 对象之一。

您发布的方法的第二个变体看起来更安全。

---

但是，如果您可以使用第三方库，我建议您查看 Google Guava，因为它们提供并发多图 (docs)。

Answer 2

第二个是正确的，但第一个不是。

想一想，假设两个线程并行调用add()。以下是可能发生的情况：

• 线程 1 调用 add("foo", bar");
• 线程 2 调用 add("foo", baz");
• 线程 1 获取“foo”的集合：null
• 线程 2 获取“foo”的集合：null
• 线程 1 创建一个新集合并在其中添加“bar”
• 线程 2 创建一个新集合并在其中添加“baz”
• 线程 1 将其集合放入映射中
• 线程 2 将其集合放入映射中

在故事的最后，地图包含一个“foo”值而不是两个。

同步地图可确保其内部状态是一致的，并且您在地图上调用的每个方法都是线程安全的。但它不会使 get-then-put 操作成为原子操作。

考虑使用 Guava 的 SetMultiMap 实现之一，它可以为您完成所有工作。将其封装到对Multimaps.synchronizedSetMultimap(SetMultimap) 的调用中，使其成为线程安全的。

Answer 3

您的第二个实现将起作用，但它持有锁的时间超过了它需要的时间（使用同步方法而不是同步块的一个不可避免的问题），这会降低并发性。如果你发现这里的并发限制是一个瓶颈，你可以把锁定的区域缩小一点。

或者，您可以使用java.util.concurrent 提供的一些无锁集合。这是我的尝试；这未经测试，它要求 Key 具有可比性，但它不应该执行任何锁定：

public class MapOfSets {
    private final ConcurrentMap<Key, Set<Value>> map;

    public MapOfSets() {
        map = new ConcurrentSkipListMap<Key, Set<Value>>();
    }

    private static ThreadLocal<Set<Value>> freshSets = new ThreadLocal<Set<Value>>() {
        @Override
        protected Set<Value> initialValue() {
            return new ConcurrentSkipListSet<Value>();
        }
    };

    public void add(Key key, Value value) {
        Set<Value> freshSet = freshSets.get();
        Set<Value> set = map.putIfAbsent(key, freshSet);
        if (set == null) {
            set = freshSet;
            freshSets.remove();
        }
        set.add(value);
    }

    public void remove(Key key, Value value) {
        Set<Value> set = map.get(key);
        if (set != null) {
            set.remove(value);
        }
    }

    //perform some operation on all elements in the set mapped to key
    public void foo(Key key) {
        Set<Value> set = map.get(key);
        if (set != null) {
            for (Value v: set) {
                v.bar();
            }
        }
    }
}

Answer 4

对于您的 Map 实现，您可以只使用 ConcurrentHashMap - 您不必担心确保访问的线程安全，无论是输入还是检索，因为实现会为您处理。

如果你真的想使用 Set，你可以调用

Collections.newSetFromMap(new ConcurrentHashMap<Object,Boolean>()) 

在您的 ConcurrentHashMap 上。