八种创建单例模式的方式-懒汉式与饿汉式及枚举-CFANZ编程社区

Java 中单例是指在整个 Java 应用中 class 只有一个实例。例如 java.lang.Runtime 就是一个单例。保证一个类仅有一个实例，并提供一个访问它的全局访问点。

在 Java5 中，创建单例很麻烦，但 Java5 引入了枚举后，就容易很多了。单例模式也就是单件模式，确保一个类只有一个实例，并提供一个全局访问点。

把某个类设计成自己管理的一个单独实例，同时也避免其他类再自行产生实例。要想取得单件实例，通过单件类是唯一的途径。同时提供对这个实例的全局访问点，当你需要实例时，向类查询，它会返回单个实例。

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

比如Hibernate 的SessionFactory，它充当数据存储源的代理，并负责创建Session 对象SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory 就够，这是就会使用到单例模式。

单例模式有八种方式：

饿汉式(静态常量)
饿汉式（静态代码块）
懒汉式(线程不安全)
懒汉式(线程安全，同步方法)
懒汉式(线程安全，同步代码块)
双重检查
静态内部类
枚举

【1】饿汉式（静态常量）

也就是说JVM加载这个类时马上创建此唯一的单件实例：

构造器私有化(防止new )
类的内部创建对象
向外暴露一个静态的公共方法-getInstance

public class TestSingleton {

  public static void main(String[] args) {
    Singleton.getInstance();
  }
}
class Singleton{
  //注意，这里有一个坑，构造器必须是private！
  private Singleton(){
    
  }
  private static Singleton instance = new Singleton();
  
  public static Singleton getInstance() {
    return instance;
  }
}

优缺点说明：

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
这种方式基于classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance 就没有达到lazy loading 的效果

结论：这种单例模式可用，可能造成内存浪费

【2】饿汉式（静态代码块）

public class TestSingleton {

  public static void main(String[] args) {
    Singleton.getInstance();
  }
}
class Singleton{
  
  private Singleton(){
    
  }
  private static Singleton instance;
  static { // 在静态代码块中，创建单例对象
    instance = new Singleton();
  }
  //3. 提供一个公有的静态方法，返回实例对象
  public static Singleton getInstance() {
    return instance;
  }
  
}

优缺点说明：

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

结论：这种单例模式可用，但是可能造成内存浪费

【3】懒汉式(线程不安全)

public class TestSingleton {

  public static void main(String[] args) {
    Singleton.getInstance();
  }
}
class Singleton{
  
  private Singleton(){
    
  }
  private static Singleton instance = null;
  
  public static Singleton getInstance() {
    if(instance == null ){
      instance = new Singleton();
    }
    return instance;
  }
  
}

优缺点说明：

起到了Lazy Loading 的效果，但是只能在单线程下使用。
如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式

结论：在实际开发中，不要使用这种方式。

【4】懒汉式(线程安全，同步方法)synchronized

此时可能会说，方法添加synchronized关键字啊，代码如下：

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

不推荐的方法–synchronized！同步getInstance()方法既简单又有效，但是可能造成程序执行效率下降100倍，如果getInstance()被调用的频繁，只能重新考虑其他方法了。因为只有第一次执行此方法时才真正需要同步。换句话说，一旦设置好instance变量，就不再需要同步这个方法。之后每次调用这个方法，同步都是一种累赘。

结论：在实际开发中，不推荐使用这种方式。

上面是同步方法，那么同样不推荐的还有同步代码块，如下所示：
八种创建单例模式的方式-懒汉式与饿汉式及枚举_枚举

【6】懒汉式之双重校验锁DCL

解决方案：双重校验锁

public class SingletonTest {
    private  static SingletonTest instance = null;
    public static void main(String[] args) {
        for (int i = 0; i < 100000; i++) {
            new Thread(new Runnable() {
                 //使用多态以及匿名类对象
                @Override
                public void run() {
                    getInstance1();//调用静态方法
                     
                }
            }).start();
        }
 
    }
    //静态方法可以使用当前类本身的class对象充当锁
    public static SingletonTest getInstance1() {
        if (instance == null) {  
            synchronized (SingletonTest.class) {  
                System.out.println("synchronized");
                if (instance == null) {  
                    System.out.println("new");
                    instance = new SingletonTest();  //注意，这里还可能出现问题
                }  
            }  
        }  //两个if判断，提高安全性
        return instance; 
    }
}

优缺点说明：

Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。
这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return 实例化对象，也避免的反复进行方法同步.
线程安全；延迟加载；效率较高

结论：在实际开发中，推荐使用这种单例设计模式

关于双重校验锁，也可以在SpringBoot的源码看到影子，如下所示ApplicationConversionService.getSharedInstance方法源码：

public static ConversionService getSharedInstance() {
        ApplicationConversionService sharedInstance = sharedInstance;
        if (sharedInstance == null) {
            Class var1 = ApplicationConversionService.class;
            synchronized(ApplicationConversionService.class) {
                sharedInstance = sharedInstance;
                if (sharedInstance == null) {
                    sharedInstance = new ApplicationConversionService();
                    sharedInstance = sharedInstance;
                }
            }
        }

        return sharedInstance;
    }

【7】静态内部类实现单例

实例代码如下：

public class Singleton {
  private Singleton() {
  }
  private static class SingletonHolder {// 静态内部类
    private static Singleton singleton = new Singleton();
  }
  public static Singleton getInstance() {
    return SingletonHolder.singleton;
  }

优缺点说明

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance 方法，才会装载SingletonInstance 类，从而完成Singleton 的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

结论：推荐使用.

【8】volatile保证内存可见性及禁止指令重排序

结束了吗？并没有！关键字volatile！！！修改代码如下：

public class SingletonTest {
   
    public static void main(String[] args) {
        for (int i = 0; i < 100000; i++) {
            new Thread(new Runnable() {
                 //使用多态以及匿名类对象
                @Override
                public void run() {
                    getInstance1();//调用静态方法
                     
                }
            }).start();
        }
 
    }
     private static volatile SingletonTest instance = null;
     
    //静态方法可以使用当前类本身的class对象充当锁
    public static SingletonTest getInstance1() {
        if (instance == null) {  
            synchronized (SingletonTest.class) {  
                System.out.println("synchronized");
                if (instance == null) {  
                    System.out.println("new");
                    instance = new SingletonTest();  
                }  
            }  
        }  //两个if判断，提高安全性
        return instance; 
    }
}

volatile关键字确保：当instance变量被初始化成SingletonTest实例时，多个线程正确地处理instance变量。

至于为什么用volatile修饰，参考博文：从内存可见性看Volatile、原子变量和CAS算法和
深入学习Java内存模型JMM。

【9】枚举类实现单例

实例代码如下：

public enum EasySingleton{
    INSTANCE;
}

可以使用EasySingleton.INSTANCE来调用。

优势：

自由序列化，线程安全，保证单例，代码简洁。这借助JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

首先，我们都知道enum是由class实现的，换言之，enum可以实现很多class的内容，包括可以有member和member function，这也是我们可以用enum作为一个类来实现单例的基础。另外，由于enum是通过继承了Enum类实现的，enum结构不能够作为子类继承其他类，但是可以用来实现接口。此外，enum类也不能够被继承，在反编译中，我们会发现该类是final的。

其次，enum有且仅有private的构造器，防止外部的额外构造，这恰好和单例模式吻合，也为保证单例性做了一个铺垫。这里展开说下这个private构造器，如果我们不去手写构造器，则会有一个默认的空参构造器，我们也可以通过给枚举变量参量来实现类的初始化。

想要了解enum是如何工作的，就要对其进行反编译。反编译后就会发现，使用枚举其实和使用静态类内部加载方法原理类似。枚举会被编译成如下形式：

public final class T extends Enum{

...

}

其中，Enum是Java提供给编译器的一个用于继承的类。枚举量的实现其实是public static final T 类型的未初始化变量，之后，会在静态代码中对枚举量进行初始化。所以，如果用枚举去实现一个单例，这样的加载时间其实有点类似于饿汉模式，并没有起到lazy-loading的作用。

对于序列化和反序列化，因为每一个枚举类型和枚举变量在JVM中都是唯一的，即Java在序列化和反序列化枚举时做了特殊的规定，枚举的writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法是被编译器禁用的，因此也不存在实现序列化接口后调用readObject会破坏单例的问题。

缺点

不能实现lazy-loading，也就是懒加载。

【10】一些问题

① 两个类加载器可能有机会各自创建自己的单件实例

每个类加载器都定义了一个命名空间，如果有两个以上的类加载器，不同的类加载器可能会加载同一个类，从整个程序来看，同一个类会被加载多次。如果这样的事情发生在单件上，就会产生多个单件并存的怪异现象。所以，如果你的程序有多个类加载器又同时使用了单件模式，请务必小心。

有一个解决办法：自行指定类加载器，并指定同一个类加载器。

② 能不能继承单件类

继承单件类会遇到一个问题，就是构造器是私有的。你不能用私有构造器来扩展类，所以你必须把单件的构造器改成公开的或受保护的。但是这么一来就不算是“真正的”单件了，因为别的类也可以实例化它了。

如果你果真把构造器的访问权限改了，还有另一个问题会出现。单件的实现是利用静态变量，直接继承会导致所有的派生类共享同一个实例变量，这可能不是你想要的。所以，想要让子类能工作顺利，基类必须实现注册表(Registry)功能。

单件模式确保程序中一个类最多只有一个实例，同时单件模式提供访问这个实例的全局点。在Java中实现单件模式需要私有的构造器、一个静态方法和一个静态变量。确定在性能和资源上的限制，然后小心地选择适当的方案来实现单件，以解决多线程的问题。

③ 单例模式注意事项和细节说明

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)