具有昂贵操作的Collection上的Java同步

Question

我有一个列表，我在我的函数doMapOperation同步命名的synchronizedMap 。 在这个函数中，我需要在地图中添加/删除项目并对这些对象执行昂贵的操作。 我知道我不想在同步块中调用昂贵的操作，但我不知道在执行这些操作时如何确保映射处于一致状态。 这样做的正确方法是什么？

这是我的初始布局，我肯定是错误的，因为你想避免在同步块中调用昂贵的操作：

public void doMapOperation(Object key1, Object key2) {
    synchronized (synchronizedMap) {

        // Remove key1 if it exists.
        if (synchronizedMap.containsKey(key1)) {
            Object value = synchronizedMap.get(key1);
            value.doExpensiveOperation(); // Shouldn't be in synchronized block.

            synchronizedMap.remove(key1);
        }

        // Add key2 if necessary.
        Object value = synchronizedMap.get(key2);
        if (value == null) {
            Object value = new Object();
            synchronizedMap.put(key2, value);
        }

        value.doOtherExpensiveOperation(); // Shouldn't be in synchronized block.
    } // End of synchronization.
}

我想作为这个问题的延续，你将如何在循环中做到这一点？

public void doMapOperation(Object... keys) {
    synchronized (synchronizedMap) {

        // Loop through keys and remove them.
        for (Object key : keys) {
            // Check if map has key, remove if key exists, add if key doesn't.
            if (synchronizedMap.containsKey(key)) {
                Object value = synchronizedMap.get(key);
                value.doExpensiveOperation(); // Shouldn't be here.

                synchronizedMap.remove(key);
            } else {
                Object value = new Object();
                value.doAnotherExpensiveOperation(); // Shouldn't here.

                synchronizedMap.put(key, value);
            }
        }
    } // End of synchronization block.
}

谢谢您的帮助。

Answer 1

您可以为synchronizedMap创建包装器，并确保containsKey ， remove和put是同步方法。 然后，只会同步对地图的访问，而昂贵的操作可以在同步块之外进行。

另一个优点是在同步块之外保留昂贵的操作，如果操作调用另一个同步映射方法，则可以避免可能的死锁风险。

Answer 2

您可以在同步块之外执行昂贵的操作，如下所示：

public void doMapOperation(Object... keys) {
    ArrayList<Object> contained = new ArrayList<Object>();
    ArrayList<Object> missing = new ArrayList<Object>();

    synchronized (synchronizedMap) {
        if (synchronizedMap.containsKey(key)) {
            contained.add(synchronizedMap.get(key));
            synchronizedMap.remove(key);
        } else {
            missing.add(synchronizedMap.get(key));
            synchronizedMap.put(key, value);
        }
    }

    for (Object o : contained)
        o.doExpensiveOperation();
    for (Object o : missing)
        o.doAnotherExpensiveOperation();
}

唯一的缺点是，您可能在从synchronizedMap中删除值后对值执行操作。

Answer 3

在第一个片段中：声明if子句中的两个值，并在if子句中分配它们。 使if子句同步，并在外部调用昂贵的操作。

在第二种情况下做同样的事情，但在循环内部。 （在循环内同步）。 当然，您可以在循环外只有一个synchronized语句，只需填写一个可以调用昂贵操作的对象List 。 然后，在同步块外部的第二个循环中，对列表中的所有值调用该操作。

Answer 4

实际上，只需一次同步命中即可完成所有操作。 第一次删除可能是最简单的。 如果您知道该对象存在，并且您知道remove是原子的，为什么不删除它，如果返回的内容不为null则调用昂贵的操作？

 // Remove key1 if it exists.
        if (synchronizedMap.containsKey(key1)) {
            Object value = synchronizedMap.remove(key1);
            if(value != null){ //thread has exclusive access to value 
              value.doExpensiveOperation();
            }
        }

对于看跌期权，因为它很昂贵而且应该是原子的，你几乎不走运，需要同步访问。 我建议使用某种计算地图。 看一下google-collections和MapMaker

例如，您可以创建一个ConcurrentMap，它将根据您的密钥构建昂贵的对象

 ConcurrentMap<Key, ExpensiveObject> expensiveObjects = new MapMaker()
       .concurrencyLevel(32)
       .makeComputingMap(
           new Function<Key, ExpensiveObject>() {
             public ExpensiveObject apply(Key key) {
               return createNewExpensiveObject(key);
             }
           });

这是一种记忆形式

在这两种情况下，您根本不需要使用synchronized （至少是显式的）

Answer 5

我们应该忘记小的效率，大约97％的时间说： 过早的优化是所有邪恶的根源 。 然而，我们不应该放弃那个关键的3％的机会。 一个好的程序员不会因为这样的推理而自满，他会明智地仔细研究关键代码; 但只有在确定了该代码之后。 - 唐纳德克努特

你有一个方法，doMapOperation（）。 如果此方法继续进行块同步，您的表现如何？ 如果您不知道，那么当您获得性能良好的解决方案时，您将如何知道？ 即使从地图中删除后，您是否已准备好处理对昂贵操作的多次调用？

我并不是想要屈尊俯就，因为你可能比你所传达的更好地理解手头的问题，但似乎你正在进入一个你可能没有准备好并且可能没有必要的优化水平。

Answer 6

如果Map没有空值，则根本不需要containsKey()调用：您可以使用Map.remove()删除该项并告诉您它是否存在。 因此，synchronized块的真实内容只需要：

Object value = Map.remove(key);
if (value != null)
  value.doExpensiveOperation();
else
{
  value = new Value();
  value.doExpensiveOperation();
  map.put(key,value);
}

如果昂贵的操作本身不需要同步，即如果您不介意Map的其他客户端在操作时看到该值，则可以进一步简化为：

Object value = Map.remove(key);
if (value == null)
{
  value = new Value();
  map.put(key,value);
}
value.doExpensiveOperation();

并且同步块可以在昂贵的操作之前终止。