这对于 Java 中的线程安全延迟加载单例来说是一个很好的实现吗？

Question

我想用 Java 实现线程安全的延迟加载单例。

这是一个好的设计吗？

public final class ThreadSafeLazySynchronizedSingleton {

private ThreadSafeLazySynchronizedSingleton(){}

private static ThreadSafeLazySynchronizedSingleton instance;

public static ThreadSafeLazySynchronizedSingleton getSynchronizedInstance(){
    synchronized(ThreadSafeLazySynchronizedSingleton.class){ 
        if (instance==null){
            instance = new ThreadSafeLazySynchronizedSingleton();
        }
        return instance;
    }
}

}

我还想创建一个无锁版本，用于一个线程比其他线程访问 Singleton 的次数更多的场景，我将如何使用 Java 中的原子对象来实现这一点，即 AtomicBoolean 或 AtomicReference 等。能否提供一个代码示例？

Answer 1

更好的设计应该是

public final class ThreadSafeLazySynchronizedSingleton {

    private ThreadSafeLazySynchronizedSingleton(){}

    private static volatile ThreadSafeLazySynchronizedSingleton instance;

    public static ThreadSafeLazySynchronizedSingleton getSynchronizedInstance(){
        if (instance==null)
            synchronized(ThreadSafeLazySynchronizedSingleton.class){ 
                if (instance==null){
                    instance = new ThreadSafeLazySynchronizedSingleton();
                }
        return instance;
        }
    }
}

但是，恕我直言，最好的设计是

public enum ThreadSafeLazySynchronizedSingleton {
    INSTANCE;
}

Answer 2

在 Java 中实现单例设计模式的推荐方法是使用枚举方法。 Enum 方法非常简单且隐式线程安全。

public enum EnumTest {
  INSTANCE;

  // Test code
  public static void main(String[] args) {

      // First thread
      Thread t1 = new Thread(new Runnable() {
         @Override
         public void run() {
             EnumTest obj = EnumTest.INSTANCE;
         }   
      });
      t1.start();

      // Second thread
      Thread t2 = new Thread(new Runnable() {
         @Override
         public void run() {
             EnumTest obj = EnumTest.INSTANCE;
         }   
      });  
      t2.start();
   }
 }

不错的教程here.

Answer 3

最简单的事情可能会像你需要的那样懒惰：

private static ThreadSafeLazySynchronizedSingleton instance
    = new ThreadSafeLazySynchronizedSingleton();

public static ThreadSafeLazySynchronizedSingleton instance() {
    return instance;
}

没错，instance 将在类加载后立即创建。但是该类在使用之前不会被加载，此时您可能需要获取实例。

如果ThreadSafeLazySynchronizedSingleton 类也有不使用instance 的静态辅助方法，这将不会像您需要的那样懒惰，但这表明它们与班上的其他人，可能应该搬到他们自己的班级。

很多人还对单例使用单值enum。我个人觉得它很丑，但它确实有一些优点（为你处理私有构造函数和instance，即使你的类是可序列化的，也会强制执行单例，否则这不是微不足道的）。

Answer 4

如果您想要一个真正的无锁实现，则需要一些旋转。否则@yshavit 或@Peter Lawrey 是最好的答案。

无锁：

private static final AtomicBoolean created = new AtomicBoolean(false);
private static volatile LazySingleton instance = null;

public static ThreadSafeLazySynchronizedSingleton getIntsance(){
   if(instance != null) return instance.get();

   if(created.compareAndSet(false, true)){
      //only one thread can try and create
      instance = new LazySingleton();
   } else {
      //other thread is creating, spin until ready
      while(instance == null);
   }
   return instance;
}