最佳实践：使用延迟初始化的线程安全Multiton模式

Question

想法是创建一个基于'type'返回不同单例实例的工厂类。 [Multiton模式]。另外，单例实例应该被延迟创建。

下面的代码线程安全吗？使用ConcurrentHashMap使其更简单，但我想尝试使用HashMap。

public class Multiton { 

    private HashMap<String, Interface> interfaceMap; 

    private static class Holder { 
     public static final Multiton INSTANCE = new Multiton(); 
    } 

    public static Multiton getInstance() { 
     return Holder.INSTANCE; 
    } 

    private Multiton(){ 
     interfaceMap = new HashMap<String, Interface>();   
    } 

    public Interface getInterface(String key){ 
     Interface value = interfaceMap.get(key); 
     if(null == value){ 
      synchronized(interfaceMap){ 
       // double check locking 
       if(interfaceMap.get(key) == null){ 
        switch(key){ 
        case TypeA : // initialize Type A interface here and put it to map 
         value = new TypeA(); 
         interfaceMap.put(key, value); 
         break; 
        case TypeB : // initialize Type B interface here and put it to map 
         value = new TypeB(); 
         interfaceMap.put(key, value); 
         break; 
        } 
       } 
      } 
     } 
     return interfaceMap.get(key); 
    } 
} 

Answer 1

Double checked locking is (in general) not thread safe。特别是，仅在写入映射时进行同步是不够的，因为这并不妨碍读者线程访问写入器线程当前正在修改的状态。

如果您不能使用ConcurrentHashMap（例如，因为您必须确保创建了一个TypeA，而不仅仅是所有客户端都使用一个TypeA），则以下内容应该可以工作并且价格合理。特别是，一旦构建了懒惰对象，它就是无锁的。

abstract class Lazy<T> { 
    private volatile T instance; 

    abstract T create(); 

    void get() { 
     if (instance == null) { 
      synchronized (this) { 
       if (instance == null) { 
        instance = create(); 
       } 
      } 
     } 
     return instance; 
    } 
} 

class Multiton { 
    private final Map<String, Lazy<?>> map = new HashMap<>(); 

    Multiton() { 
     map.put("A", new Lazy<A> { 
      A create() { 
       return new A(); 
      } 
     } 
     map.put("B", new Lazy<B> { 
      B create() { 
       return new B(); 
      } 
     } 
     // and so on for the other types 
    } 
} 

生产质量，你可能要考虑使用lamdba表达式的工厂方法，以及地图（如要求接口的类的对象）类型安全密钥。