2

我正在尝试创建一个使用 set-within-a-map 线程安全的类。我不确定what特别需要同步。

该地图被定义为类似于 的东西Map<Class<K>, Set<V>> map;。以下是地图在实现内部使用的方式的简化：

public void addObject(K key, V object) {
    getSet(key).add(object);
}

public void removeObject(K key, V object) {
    getSet(key).remove(object);
}

public void iterateObjectsInternally(K key, Object... params)
{
    for (V o : getSet(key)) {
        o.doSomething(params);
    }
}

private Set<V> getSet(K key) {
    if (!map.containsKey(key)) {
        map.put(key, new Set<V>());
    }

    return map.get(key);
}

地图问题

就使用map本身而言，我看到的唯一并发问题是 in ，线程上下文可能在和getSet(K)之间切换。在这种情况下，可能会发生以下情况：containsKeyput

[Thread A] map.containsKey(key)       => returns false
[Thread B] map.containsKey(key)       => returns false
[Thread B] map.put(key, new Set<V>())
[Thread B] map.get(key).add(object)
[Thread A] map.put(key, new Set<V>()) => Thread A ovewrites Thread B's object [!]
[Thread B] map.get(key).add(object)

现在，我目前正在HashMap为此实现使用常规。而且，如果我是正确的，使用Collection.synchronizedMap()or ConcurrentHashMapwill 只会解决方法级别的并发问题。也就是说，方法将以原子方式执行。这些并没有说明方法之间的交互方式，因此即使使用并发解决方案，以下情况仍然可能发生。

ConcurrentHashMap但是，确实有方法putIfAbsent。这样做的缺点是该语句map.putIfAbsent(key, new Set<V>())将在每次请求集合时创建一个新集合。这似乎是很多开销。

另一方面，仅仅将这两个语句包装在一个同步块中就足够了吗？

synchronized(map) {
    if (!map.containsKey(key)) {
        map.put(key, new Set<V>());
    }
}

有没有比锁定整个地图更好的方法？有没有办法只锁定键，以便读取地图的其他值不会被锁定？

synchronized(key) {
    if (!map.containsKey(key)) {
        map.put(key, new Set<V>());
    }
}

请记住，键不一定是同一个对象（它们是特定的Class<?>类型），而是通过哈希码相等。如果同步需要对象地址相等，则同步key可能不起作用。

设置问题

我认为，更大的问题是知道这套设备是否被正确使用。有几个问题：添加对象、删除对象和迭代对象。

将列表包装起来Collections.synchronizedList是否足以避免和中的并发addObject问题removeObject？我假设这会很好，因为同步包装器会使它们成为原子操作。

但是，迭代可能是另一回事。对于iterateObjectsInternally，即使集合是同步的，它仍然必须在外部同步：

Set<V> set = getSet(key);
synchronized(set) {
    for (V value : set) {
        // thread-safe iteration
    }
}

然而，这似乎是一种可怕的浪费。相反，如果我们将简单地替换为使用CopyOnWriteArrayList或CopyOnWriteArraySet作为定义会怎样。由于迭代只会使用数组内容的快照，因此无法从另一个线程对其进行修改。此外，CopyOnWriteArrayList在 add 和 remove 方法上使用可重入锁，这意味着 add/remove 本质上也是安全的（因为它们是同步方法）。CopyOnWriteArrayList看起来很有吸引力，因为内部结构的迭代次数远远超过列表上的修改次数。此外，使用复制的迭代器，无需担心addObject或removeObject弄乱另一个线程中iterateObjectInternally( ) 的迭代。ConcurrentModificationExceptions

这些并发检查是否在正确的轨道上和/或足够严格？我是一个有并发编程问题的新手，我可能遗漏了一些明显的或过度思考的东西。我知道有一些类似的问题，但我的实现似乎足够不同，足以保证像我一样具体地提出问题。

4

2 回答 2

1

你肯定是想多了。根据您的并发特征使用简单的 ConcurrentHashMap 和 ConcurrentSkipListSet/CopyOnWriteArraySet（主要是如果迭代需要考虑数据的动态修改）。使用类似于以下代码段的内容作为 getSet 方法：

private Set<V> getSet(K key) {
    Set<V> rv = map.get(key);
    if (rv != null) {
        return rv;
    }
    map.putIfAbsent(key, new Set<V>());
    return map.get(key);
}

这将确保在添加/删除对象时正确的无锁并发，对于迭代，您需要确定丢失更新是否是您的问题域中的问题。如果在迭代期间添加新对象时错过它不是问题，请使用 CopyOnWriteArraySet。

第三，您想深入了解可以使用哪种粒度的并发性，您的要求是什么，在边缘情况下的正确行为是什么，最重要的是，您的代码必须具备哪些性能和并发特性封面 - 如果它在启动时发生两次，我会让所有方法同步并完成它。

于 2012-08-24T00:53:34.843 回答
0

如果您要经常添加到“集合”，CopyOnWriteArrayList 和 CopyOnWriteArraySet 将不可行 - 它们使用太多资源进行添加操作。但是，如果您很少添加并且经常迭代“集合”，那么它们是您最好的选择。

Java ConcurrentHashMap 将每个地图本身放入一个存储桶中 - 如果不存在，则您的 put if 操作将在搜索密钥时锁定列表，然后释放锁定并放入密钥。绝对使用 ConcurrentHashMap 而不是地图。

您的 getSet 方法本身可能会很慢，尤其是在同步时 - 也许您可以尽早预加载所有键和集合。

我建议你按照 Louis Wasserman 所说的去做，看看你在 Guava 实现中的表现是否不错。

于 2012-08-24T00:55:54.560 回答