单例模式的实现策略

 

1. 懒汉模式——线程不安全写法

   //这种写法不适合多线程下使用，多线程下有可能会被创建出多个Singleton实例
   public class Singleton { 
       //私有静态变量，使其只在内存中加载一份
       private static Singleton instance; 
       //私有化构造方法，使其无法被new出实例
       private Singleton (){} 
   
       //静态方法构造对象并返回
       public static Singleton getInstance() { 
               if (instance == null) { 
              instance = new Singleton(); 
               } 
               return instance; 
       } 
   }

    

2. 懒汉模式——线程安全写法

   //实例化对象的方法加入同步关键字声明，使得线程安全
   public class Singleton { 
       private static Singleton instance; 
       private Singleton (){} 
   
       //在同步方法中创建实例对象，多线程时安全。
       public static synchronized Singleton getInstance() { 
               if (instance == null) { 
                instance = new Singleton(); 
               } 
               return instance; 
       } 
   }  

    

3. 懒汉模式——双重锁检查

   /**
   * 双重锁检查机制：
   *    创建对象实例的方法中检查两次对象是否为空
   *    加锁之后在检查一次
   * volatile：保证了内存可见性
   */
   public class Singleton { 
       private volatile static Singleton singleton; 
       private Singleton (){} 
       public static Singleton getSingleton() { 
               if (singleton == null) {           //Single Checked
                   synchronized (Singleton.class) { 
                       if (singleton == null) {  //Double Checked
                               singleton = new Singleton(); 
                       } 
                   } 
               } 
               return singleton; 
           } 
   }

    

4. 饿汉模式

   public class Singleton { 
       //在声明变量的同时创建出实例对象,加了static关键字修饰，使其只在堆中创建一次
       private static Singleton instance = new Singleton(); 
       private Singleton (){} 
       public static Singleton getInstance() { 
            return instance; 
       } 
   }

    

5. 饿汉模式——变种写法

   public class Singleton { 
       private Singleton instance = null; 
       //类加载时,在静态代买块中创建实例对象
       static { 
               instance = new Singleton(); 
       } 
       private Singleton (){} 
       public static Singleton getInstance() { 
               return this.instance; 
       } 
   }

    

6. 静态内部类

   /**
   *Singleton类被装载instance不一定被初始化，因为内部类SingletonHolder没有被主动使用，只有显示*调用getInstance才会显示装载SingletonHolder 类，从而实例化instance
   */
   public class Singleton { 
       private static class SingletonHolder { 
           //声明对象为常量形式
            private static final Singleton INSTANCE = new Singleton(); 
       } 
       private Singleton (){} 
       public static final Singleton getInstance() { 
            return SingletonHolder.INSTANCE; 
       } 
   }   

    

7. 枚举

   /**
   *枚举（既可以避免多线程同步问题，还可以防止被反序列化重建对象）
   */
   public enum Singleton { 
       INSTANCE;
   public void whateverMethod() {
   } 
   public static void main(String[] args) {
           Singleton s = Singleton.INSTANCE;
           Singleton s2 = Singleton.INSTANCE;
           System.out.println(s==s2);
   }
   }