HashMap 缓存中的同步

Question

我有一个网络应用程序，人们可以在其中请求资源。为了提高效率，这些资源使用同步哈希图进行缓存。这里的问题是，当两个不同的请求同时针对同一未缓存的资源时：检索资源的操作会占用大量内存，因此我想避免对同一资源多次调用它。

有人可以告诉我以下代码片段是否存在任何潜在问题吗？提前致谢。

private Map<String, Resource> resources = Collections.synchronizedMap(new HashMap<String, Resource>());

public void request(String name) {

  Resource resource = resources.get(name);

  if (resource == null) {
    synchronized(this) {
      if (resources.get(name) == null) {
        resource = veryCostlyOperation(name); // This should only be invoked once per resource...
        resources.put(resource);
      } else {
        resource = resources.get(name);
      }
    }
  }

  ...

}

Answer 1

一个可能的问题是，通过在 synchronized 块内执行 veryCostlyOperation() 会产生不必要的争用，从而导致许多线程无法同时检索其（独立）资源。这可以通过使用 Future 作为地图的值来解决：

Map<String, Future<Resource>> map = new ConcurrentHashMap<String, Future<Resource>>();    
...
Future<Resource> r = map.get(name);
if (r == null) {
    FutureTask task = null;
    synchronized (lock) {
        r = map.get(name);
        if (r == null) {
            task = new FutureTask(new Callable<Resource>() {
                public Resource call() {
                    return veryCostlyOperation(name);
                }
            });
            r = task;
            map.put(name, r);
        }
    }
    if (task != null) task.run(); // Retrieve the resource
}

return r.get(); // Wait while other thread is retrieving the resource if necessary

Answer 2

我发现的唯一潜在问题是您同步到this。如果同一类中的任何其他代码也同步到 this，则只会同时运行这些块之一。也许没有其他东西可以做到这一点，那很好。不过，我总是担心下一个程序员会做什么。 （或者我自己在三个月内忘记了这段代码）

我建议创建一个通用同步对象，然后同步到它。

private final Object resourceCreationSynchObject = new Object();

否则

synchronized(this.resourceCreationSynchObject) {
  ...
}

，这正是您所要求的。它确保veryCostlyOperation不能被并行调用。

此外，在 synchronized 块中再次重新获取资源也是一个很好的想法。这是必要的，并且外部的第一次调用可确保您在资源已经可用时不会同步。但没有理由第三次调用它。在 synchronized 块中，首先将 resource 再次设置为 resources.get(name)，然后检查该变量是否为 null。这将防止您必须在 else 子句中再次调用 get 。

Answer 3

您的代码看起来不错，只是您同步的内容超出了实际需要的内容：

• 使用 ConcurrentHashMap 而不是同步的 HashMap 将允许多次调用 get 方法而无需锁定.

• 在 this 上同步而不是在 resources 上同步可能没有必要，但这取决于代码的其余部分。

Answer 4

您的代码可能会多次调用veryCostlyOperation(name)。问题在于，查找映射后存在一个不同步的步骤：

public void request(String name) {
    Resource resource = resources.get(name);
    if (resource == null) {
        synchronized(this) {
            //...
        }
    }
    //...
}

映射中的 get() 已由映射同步，但检查结果是否为 null 不受任何保护。如果多个线程进入此请求相同的“名称”，则所有线程都会从 resources.get() 看到 null 结果，直到一个线程实际完成 costlyOperation 并将资源放入资源映射中。

一种更简单、有效但可扩展性较差的方法是使用法线贴图并使整个请求方法同步。除非在实践中确实出现问题，否则我会选择简单的方法。

为了获得更高的可扩展性，您可以通过在synchronized(this)之后再次检查地图来修复您的代码以捕获上述情况。它仍然无法提供最佳的可扩展性，因为synchronized(this)只允许一个线程执行costlyOperation，而在许多实际情况下，您只想防止同一资源的多次执行，同时允许对不同资源的并发请求。在这种情况下，您需要一些工具来同步所请求的资源。一个非常基本的例子：

private static class ResourceEntry {
     public Resource resource;
}

private Map<String, ResourceEntry> resources = new HashMap<String, ResourceEntry>();

public Resource request(String name) {
    ResourceEntry entry;
    synchronized (resources) {
        entry = resources.get(name);
        if (entry == null) {
            // if no entry exists, allocate one and add it to map
            entry = new ResourceEntry();
            resources.put(name, entry);
        }
    }
    // at this point we have a ResourceEntry, but it *may* be no loaded yet
    synchronized (entry) {
        Resource resource = entry.resource;
        if (resource == null) {
            // must create the resource
            resource = costlyOperation(name);
            entry.resource = resource;
        }
        return resource;
    }
}

这只是一个粗略的草图。基本上，它对 ResourceEntry 进行同步查找，然后在 ResourceEntry 上进行同步，以确保特定资源仅构建一次。