在 HashMap 中延迟加载和缓存对象的方法是否应该同步？

Question

这个方法应该同步吗？我想我不明白上下文切换是如何（以及何时）发生的，所以我不知道是否有可能多个线程进入我的方法内的 if 块。

public class ServiceLocator {
    private static final Map<Class, Object> applicationServices =
            new HashMap<Class, Object>();

    /**
     * Locates an application scoped service.  The service is lazy loaded and
     * will be cached permanently.
     *
     * @param type The type of service to locate.
     * @return An application scoped service of the specified type.
     */
    @SuppressWarnings({"unchecked"})
    public synchronized static <T> T getApplicationService(Class<T> type) {
        if(!applicationServices.containsKey(type)) {
            // If this method is NOT synchronized, is it possible for more than
            // one thread to get into this if block?
            T newService = ServiceLoader.create(type);
            applicationServices.put(type, newService);
            return newService;
        }
        return (T) applicationServices.get(type);
    }
}

Answer 1

是的，你说得对，这个方法需要同步。从技术上讲，上下文切换可以发生在代码中的任意两行之间，甚至可以发生在代码内部（例如，在 ++i 中读取和存储 i 之间）。

请注意，使用synchronized关键字并不意味着当线程处于同步块时线程不会被中断并且不会发生上下文切换。它仅意味着尝试在其他线程中执行相同代码的任何其他线程都会阻塞，从而有效地允许拥有锁的线程继续。

即使使用 ConcurrentHashMap 也无济于事，因为安全的 putIfAbsent() 方法需要给定键已有值 - 并且您可能不想每次都急于创建服务。

然而，对于这个相当常见的问题，有一些性能更好的方法，例如，请参阅：如何实现自填充 EHcache？

Answer 2

正如其他人提到的，您需要同步以确保不会创建多个服务实例。

您应该查看用于初始化单例的双重检查锁定惯用法，以提高此处的性能。

例如，getApplicationService 本身不需要同步。在大多数情况下，它会在缓存中找到服务，并且仅当您在映射中找不到该元素时才需要锁定：

public static <T> T getApplicationService(Class<T> type) {
    // applicationServices needs to be a ConcurrentHashMap otherwise 
    // the following containsKey can conflict with the subsequent put
    if(!applicationServices.containsKey(type)) {
        // need to synchronize before modifying the map
        synchronized(applicationServices) {
            // check if another thread created the same service while 
            // we were waiting for the lock
            if(!applicationServices.containsKey(type)) {
                T newService = ServiceLoader.create(type);
                applicationServices.put(type, newService);
            }
        }
    }
    return (T) applicationServices.get(type);
}

Answer 3

synchronized 是使其成为线程安全的最简单方法，但不是最有效的方法。

如果没有synchronized，您的代码将会有两个问题：

• HashMap 不是线程安全的，不应该在没有同步的情况下从多个线程使用它。
• 当另一个线程（具有相同 type）已位于其中时，一个线程可以进入 if 块，因此相同 type 的两个实例将被创建。

因此，如果 synchronized 的解决方案不能满足您的需求，您需要通过其他方式解决这两个问题。第一个问题可以通过使用ConcurrentHashMap来解决。第二个更复杂，可以通过将 FutureTask 放入映射中来解决，例如 这个。

Answer 4

@Tomasz Nurkiewicz

可以使用 putIfAbsent() 来竞争锁；第一个线程创建服务；其他线程等待通知。这样，我们就不会只为一项服务锁定整个地图，从而导致卡住。他们甚至给它起了一个奇怪的名字，谷歌“memoizer”。在某些情况下，带有 FutureTask 的 Impl 实际上存在细微的错误或不良行为。

对这样一个实用程序的需求——根据第一需求计算一些东西然后缓存它——是相当强烈的。一个好的实现并不是微不足道的，普通程序员不应该费心去重新发明它。 Java8 可能会发布类似的东西。目前人们可以使用Guava的计算地图。