线程安全的单例模式几种实现方式

饿汉式单例

public class Singleton {  
   private final static Singleton INSTANCE = new Singleton();

   private Singleton() { }
   public static Singleton getInstance() {
      return INSTANCE;
   }
}

虽然只会只有一个对象,问题是每次加载类的时候就会创建,多的话考虑性能问题。

借助内部类实现懒汉式

因为Java机制规定,内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载(实现了lazy),而且其加载过程是线程安全的。内部类加载的时候实例化一次instance。

public class Singleton {

   private Singleton() { }

   private static class SingletonHolder {
      private final static Singleton INSTANCE = new Singleton();
   }
   public static Singleton getInstance() {
      return SingletonHolder.INSTANCE;
   }
}

双重检测

但要注意写法(考虑JVM指令重排序问题)

public class Singleton {  
   private static Singleton instance = null;

   private Singleton() { }
   public static Singleton getInstance() {
      if(instance == null) {
         synchronzied(Singleton.class) {
            Singleton temp = instance;
            if(temp == null) {
               temp = new Singleton();
               instance = temp
            }
         }
      }
      return instance;
   }
}

由于指令重排序问题,所以不可以直接写成下面这样:

public class Singleton {  
   private static Singleton instance = null;
   private Singleton() { }
   public static Singleton getInstance() {
      if(instance == null) {
         synchronzied(Singleton.class) {
            if(instance == null) {
               instance = new Singleton();
            }
         }
      }
      return instance;
   }
}

但是如果instance实例变量用volatile修饰就可以了,volatile修饰的话就可以确保instance = new Singleton();对应的指令不会重排序,如下的单例代码也是线程安全的:

public class Singleton {  
   private static volatile Singleton instance = null;
   private Singleton() { }
   public static Singleton getInstance() {
      if(instance == null) {
         synchronzied(Singleton.class) {
            if(instance == null) {
               instance = new Singleton();
            }
         }
      }
      return instance;
   }
}

张鹏宇

继续阅读此作者的更多文章