Question

我正在开发计算机视觉应用程序，我将需要Classifier类。这个类在每次运行时都是不可变的，它在初始化时从磁盘加载训练过的数据。我想确保整个程序可以访问相同的训练数据，并且我希望在加载后阻止从磁盘重新加载。

我考虑的是使用静态类或单例。我不确定如何将数据加载到静态类，因为在编译时不知道数据文件的路径 - 它将是程序参数。所以我在考虑Singleton模式，但我不知道如何动态初始化它。

我的想法是使用以下内容：

class Singleton {
    private static Singleton instance;
    private Singleton() { ... }
    private static SomeDataObject data;

    public static Singleton getInstance() {
        if(instance == null)
            instance = new Singleton();

            return instance;
    }

    public static init(string dataPath){
        if(data == null)
             loadDataFromFile(dataPath)
    }
}

这会无效，因为我无法控制首先调用哪种方法。

我知道正确的方法是在开始时用数据创建实例并将其传递给所有需要它的类和方法，但这不是真正的通用解决方案。我可以在自己的代码中跟踪对Classifier的所有调用，但是如果我将代码作为API，这将是一个问题。

简而言之，如何在运行时初始化单例？

Answer 1

我认为（确切地说）你想做的事情会起作用。

以下内容可行：

public static void main(String[] args)
{
  Singleton.init("somepath");
  ...
  Singleton.getInstance().doingStuff();
  ...
}

更好的实现可能是:(如果您尝试使用NullPointerException而不首先调用init，则会导致private static Singleton instance; private SomeDataObject data; private Singleton(String path) { loadDataFromFile(path); ... } public static Singleton getInstance() { return instance; } public static void init(String dataPath){ instance = new Singleton(dataPath); }）（尽管不再是Singleton）

class Main
{
  public static void main(String[] args)
  {
    Singleton.currentPath = "somepath";
    ...
  }
}

class Singleton
{
  public static String currentPath = null;
  private static Singleton instance;
  private SomeDataObject data;

  private Singleton(String path) { loadDataFromFile(path); ... }

  public static Singleton getInstance() {
     if(instance == null && currentPath != null)
        instance = new Singleton(currentPath);
     return instance;
  }
}

然后是:(可能不好的编码习惯）

{{1}}

我认为并没有真正解决太多。

Answer 2

我使用的东西比当前获胜的解决方案“更”线程安全，几乎没有同步使用。

import java.util.function.Supplier;

public class InitOnce {

/**
 * Marked as final to prevent JIT reordering
 */
private final Supplier<String> theArgs;

private InitOnce(Supplier<String> supplier) {
    super();
    this.theArgs = supplier;
}

/**
 * Uses the arguments to do something
 * 
 * @return
 */
public String doSomething() {
    return "Something : " + theArgs.get();
}

/**
 * Initializes all the things
 * 
 * @param someArgs
 */
public static synchronized void init(final Supplier<String> someArgs) {
    class InitOnceFactory implements Supplier<InitOnce> {
        private final InitOnce initOnceInstance = new InitOnce(someArgs);

        @Override
        public InitOnce get() {
            return initOnceInstance;
        }
    }

    if (!InitOnceFactory.class.isInstance(instance)) {
        instance = new InitOnceFactory();
    } else {
        throw new IllegalStateException("Already Initialized");
    }
}

private static Supplier<InitOnce> instance = new InitOnceHolder();

/**
 * Temp Placeholder supplier
 * 
 */
private static final class InitOnceHolder implements Supplier<InitOnce> {
    @Override
    public synchronized InitOnce get() {

        if (InitOnceHolder.class.isInstance(instance))
            throw new IllegalStateException("Not Initialized");

        return instance.get();
    }

}

/**
 * Returns the instance
 * 
 * @return
 */
public static final InitOnce getInstance() {
    return instance.get();
}
}

带参数的单例类

2 个答案: