Question

我在单例数据结构中有一个单例。目前我的实现如下：

public class Singleton {
    private Object embInstance;

    private Singleton() { 
        embInstance = new Object();
    }

    private static class SingletonHolder { 
            public static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
            return SingletonHolder.instance;
    }

    public Object getEmbInstance() {
        return embInstance;
    }

    public Object resetEmbInstance() {
        embInstance = null;
    }

}

我的问题是：

'private Singleton（）'是否必须为空或是否可以在其中添加一些代码？
这个实现是否与embInstance相关？
此实现不是对embInstance的延迟加载。如何为embInstance实现线程安全的延迟加载？

谢谢！

Answer 1

可以将一些代码添加到私有的无参数构造函数中。
我相信SingletonHolder类只会初始化一次，因此保证实例只分配一次。但是，在Singleton类中，你有不同步的setter和getter，所以你可能在embInstance中遇到一些线程问题。

线程安全的延迟加载：与延迟加载相同，但在同步块内执行：

public static Object getInstance() {
    if(embInstance == null) {
        synchronized(Singleton.class) {
            if(embInstance == null) {
                embInstance = new Singleton();
            }
        }
    }

    return embInstance;
}

请注意，此代码既有效（初始化数据后也不需要同步）和线程安全（初始化发生在同步块内）。

希望有所帮助。

Answer 2

synchronized关键字使方法保持线程安全。 getEmbInstance()是进行延迟实例化的标准方法。

public class Singleton {
    private Object embInstance;

    private Singleton() { 
    }

    private static class SingletonHolder { 
            public static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
            return SingletonHolder.instance;
    }

    public synchronized Object getEmbInstance() {
        if (embInstance == null)
            embInstance = new Object();
        return embInstance;
    }

    public synchronized Object resetEmbInstance() {
        embInstance = null;
    }
}

Answer 3

....呃......那不是过于复杂的事吗？为什么在单身人士中有单身人士？为什么这么多课？

此外，你有一个方法可以将你的单例“重置”为null，但是没有一个方法可以实际实例化一个新单元。

为什么不简单：

public class Singleton {
    private static Singleton instance;

    private Singleton() { }

    public static synchronized Singleton getInstance() {
              if (instance == null)
                     instance = new Singleton(); // The "lazy loading" :p
          return instance;
    }
}

Answer 4

不确定，是什么意思。在Singleton构造函数
这本身并不是线程安全的。如果embInstance被多个线程访问，即使它是通过getEmbInstance，它也会受到竞争条件的影响。如果您希望线程安全，则必须使用synchronized来访问它。
要实现线程安全的延迟加载，您必须拥有一个阻止更改Singleton的锁。您可以使用Singleton的实例将其锁定为：

synchronized(this)

另外，您不需要SingletonHolder public static Singleton instance类本身就可以Singleton。

Answer 5

public class A {
    A a;
    private A() {}

    synchronized public static A getOb() {
        if (a == null) {
            a = new A();
        }
        return a;
    }
}

您应该在Singleton中使用synchronized来保证线程安全。

单身单身人士

5 个答案: