如何在 Java 中正确创建线程安全的单例工厂？ [复制]

Question

这是我第一次写Factory 类。下面是我的工厂类，我不确定这是否是使线程安全的单例工厂类的正确方法。我将使用这个工厂返回我的客户实例吗？

public class ClientFactory {

    private static ClientFactory instance = null;   

    private ClientFactory() {

    }

    public static ClientFactory getInstance() {

        if (instance == null)
        {
            instance =  new ClientFactory();
        }

        return instance;
    }

    public IClient getClient() {

        return new TestClient();
    }
}

这是我的 TestClient 类 -

public class TestClient implements IClient {


}

这就是我将如何使用我的工厂 -

IClient client = ClientFactory.getInstance().getClient();

Answer 1

事实上，您的工厂不是线程安全的，因为在竞争条件下，您可以在应用程序中拥有多个 ClientFactory。让我们假设两个线程：

1. ThreadA 正在评估条件“if (instance == null)”且实例为 null，因此它进入语句
2. ThreadB 正在评估条件 'if (instance == null)' 并且 instance 为 null（因为 A 没有实例化它），所以它进入语句
3. ThreadA 创建新的 ClientFactory() 并返回它
4. ThreadB 创建新的 ClientFactory() 并返回它
5. 现在我们在应用程序中有多个 ClientFactory。当然，稍后尝试检索实例的其他线程将始终返回单个实例。

在我看来，用 Java 编写单例最简单的方法是使用枚举。在你的情况下，它看起来：

public enum ClientFactory {
  INSTANCE;

  public Company getClient() {
    return new Company();
  }
}

及用法：

ClientFactory.INSTANCE.getClient()

Answer 2

单件和工厂是不同的东西。要属性构造一个 Singleton，我想您可以将其 getInstance() 方法视为一个工厂。工厂制造“东西”。单例意味着在任何时候都只会存在 0 个或恰好 1 个这些“事物”。

如果你想创建一个合适的 Singleton，在 Java 中以线程安全的方式来做这件事是非常麻烦的。如果没有同步或其他线程安全对策，您上面列出的代码在 check-then-set 代码周围有一个微妙的竞争条件，以初始化 ClientFactory 实例变量。围绕这种竞争条件有两种方法。您选择哪种方式很大程度上取决于通过 ClientFactory 构造函数的成本。我的构造函数通常是轻量级的，所以我走的是避免同步需要的路径。

public class ClientFactory {
    private static final ClientFactory instance = new ClientFactory();

    private ClientFactory() { }

    public static ClientFactory getInstance() {
        return instance;
    }
}

如果你想在构造中“懒惰”，直到有人显式调用 getInstance() 才开始构建，现在需要同步以避免竞争条件。

public class ClientFactory {
    private static ClientFactory instance = null;

    private ClientFactory() { }

    public static synchronized ClientFactory getInstance() {
        if ( instance == null ) {
            instance = new ClientFactory();
        }
        return instance;
    }
}

Answer 3

Wiki 上的线程安全实现（示例） - Singleton Pattern on Wikipedia

与上面的链接一样，单元素 enum 类型是为任何支持枚举的 Java 实现 Singleton 的最佳方式。

最好但最简单的一个：

public class ClientFactory{
    private ClientFactory() {}

    private static ClientFactory INSTANCE=null;

    public static ClientFactory getInstance() {
        if(INSTANCE==null){
            synchronize(ClientFactory.class){
                if(INSTANCE==null) // check again within synchronized block to guard for race condition
                    INSTANCE=new ClientFactory();
            }
        }
        return INSTANCE;
    }
}

Source:Wikipedia

Answer 4

你的工厂是一个完美的单例（只是它不是线程安全的）。

Answer 5

ClientFactory 是一个工厂，但既不是单例工厂，也不是线程安全工厂。 在任何时候，当 ClientFactory.getInstance().getClinet() 被调用时，它都会返回一个新的 实例，所以它不是绝对的单例工厂。如果我们像这样修复方法

private IClient iclient;

public IClient getClient() {

    if ( iclient == null ){
         iclient = new TestClient();
    }

    return iclient ;
}

那么工厂是一个单例工厂，但它不是线程安全的。 假设如果有多个线程调用getInstance，所有线程都会找到 客户端工厂实例为空，所以他们将分别构造实例， 问题与getClient()方法相同。

很容易修复，你可以将这两个方法声明为同步。

首先，如果你真的想使用工厂模式，别忘了隐藏客户端的构造函数

private TestClient(){
}