为泛型类的每个类型参数创建单独的单例的最佳习惯用法？

Question

（也许是"How to create a generic singleton class in java?"的补充问题：）

class MyClass<T> {
    private static Map<Class<MyClass<?>>, MyClass<?>> s_instances =
        new HashMap<Class<MyClass<?>>, MyClass<?>>();

    public static MyClass<?> blah(Class<MyClass<?>> clz)
            throws InstantiationException, IllegalAccessException {
        if (s_instances.get(clz) != null)
            return s_instances.get(clz);
        MyClass<?> instance = clz.newInstance();
        s_instances.put(clz, instance);
        return instance;
    }
}

有没有更好的习惯用法来表示每个类型参数值都只有一个单例？

编辑：请不要仅仅为了指出缺乏线程安全而回答。取点。我在问我是否可以做一些比这张地图更优雅的事情。

Answer 1

请不要那样做。
A. 你的单例不是线程安全的。
B. 注意double check pattern issues at Java。
C. 每个类中都有静态初始化器真的那么难吗：

static {
   instance = new MySingleton();
}

然后

public static MySingleton getInstance() {
return instance
}

如果你真的坚持 -
1.您可能可以定义一个单例，它将管理映射到实例中的类型（键是类或完整的类名，值是对象）
2.您可以在那里添加注册您想要的类型（我建议他们有私人CTOR）。
3. 使用this 答案以调用私有 CTOR ，并创建一个实例以放置在映射条目的值中。
4. 为1中提到的repository提供一个getInstance方法，签名为：

public Object getInstanceByType(Class<?> clazz)

此方法将从内部映射中获取实例。

Answer 2

你的方法不是线程安全的：

private static Map<Class<MyClass<?>>, MyClass<?>> s_instances =
    new HashMap<Class<MyClass<?>>, MyClass<?>>();

public static MyClass<?> blah(Class<MyClass<?>> clz)
        throws InstantiationException, IllegalAccessException {
    if (s_instances.get(clz) != null)
        return s_instances.get(clz);
    // here1
    MyClass<?> instance = clz.newInstance();
    s_instances.put(clz, instance);
    // here2
    return instance;
}

一旦一个线程越过标记为//here1 的行，第二个线程可能会在第一个线程到达标记为//here2 的行之前进入该方法，因此创建第二个相同类型的“单例”并覆盖第一个在地图中。

快速解决方法是在地图上同步：

public static MyClass<?> blah(Class<MyClass<?>> clz)
        throws InstantiationException, IllegalAccessException {
  synchronized(s_instances){
    if (s_instances.get(clz) != null)
        return s_instances.get(clz);
    // here1
    MyClass<?> instance = clz.newInstance();
    s_instances.put(clz, instance);
    // here2
    return instance;
  }
}

但是，这意味着许多线程将不得不等待很多时间，最终可能会杀死您的应用程序。可能你应该做的是一个两步解决方案：

public static MyClass<?> blah(Class<MyClass<?>> clz)
        throws InstantiationException, IllegalAccessException {
  Object candidate = s_instances.get(clz);
  if(clz.isInstance(candidate)){ // implicit null check
      return clz.cast(candidate);
  }
  synchronized(s_instances){
    Object candidate = s_instances.get(clz);
    if(clz.isInstance(candidate)){  // gotta check a second time in a
        return clz.cast(candidate); // synchronized context
    }
    MyClass<?> instance = clz.newInstance();
    s_instances.put(clz, instance);
    return instance;
  }
}

另外，HashMap 不适合并发访问，所以你应该把它包装在Collections.synchronizedMap()：

private static Map<Class<MyClass<?>>, MyClass<?>> s_instances =
    Collections.synchronizedMap(new HashMap<Class<MyClass<?>>, MyClass<?>>());

或者改用ConcurrentHashMap。