[Java知识点] 单例模式 六种方法实现以及优缺点总结

单例模式

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

延迟加载：将类的实例化过程延迟到需要时的过程。延迟初始化技术演示了在需要使用类字段时对其进行值检查。如果该类字段值为空，则该字段会在返回之前使用正确的值进行更新。

懒汉式线程不安全

是否 Lazy 初始化：是

是否多线程安全：否

描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized。

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

懒汉式线程安全

是否 Lazy 初始化：是

是否多线程安全：是

描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。 优点：第一次调用才初始化，避免内存浪费。 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

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

饿汉式

是否 Lazy 初始化：否

是否多线程安全：是

描述：这种方式比较常用，但容易产生垃圾对象。

优点：没有加锁，执行效率会提高。 缺点：类加载时就初始化，浪费内存。

它基于 classloader 机制(类加载时就实例化，多个线程访问的是同一个实例)避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

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

DCL

双重检查锁(DCL，即 double-checked locking)

JDK 版本：JDK1.5 起

是否 Lazy 初始化：是

是否多线程安全：是、

这种方式采用双锁机制，安全且在多线程情况下能保持高性能。提高了效率。

DCL，涉及到三个要点：

1. 加锁(同步代码块)保证线程安全

2. 双重if保证效率

3. 使用使用volatile来禁止指令重排(防止DCL失效)。

   因为编译器优化、多处理器共享内存的情况下，DCL并不能正常工作；

   在java中volatile保证了可见性和有序性，有序性也即禁止指令重排，那么我们看到DCL的代码中使用了synchronized关键字，而该关键字底层通过moniter_enter和monitor_exit两个字节码来完成，该字节码自身已经完成的可见性，所以我们这里使用volatile肯定不是因为可见性而使用得，那么只有一个答案，那就是禁止指令重排。那么为何需要禁止指令重排呢？

   编译器优化，会导致指令重排，导致DCL出现问题

   需要知道的是instance = new Singleton();这句代码并不是一个原子操作,他的操作大体上可以被拆分为三步

   1.分配内存空间

   2.实例化对象instance

   3.把instance引用指向已分配的内存空间,此时instance有了内存地址,不再为null了

   java是允许对指令进行重排序, 那么以上的三步的执行顺序就有可能是1-3-2. 在这种情况下, 如果线程A执行完1-3之后被阻塞了, 而恰好此时线程B进来了 此时的instance已经不为空了所以线程B走完代码以后就直接返回了这个还没有实例化好的instance, 所以在调用其后续的实例方法时就会得不到预期的结果，这就是常说的DCL失效问题。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
        if (singleton == null) {  
            synchronized (Singleton.class) {  
                if (singleton == null) {  
                    singleton = new Singleton();  
                }  
            }  
    }  
    return singleton;  
    }  
}

静态内部类

initialization on demand holder模式

是否 Lazy 初始化：是

是否多线程安全：是

描述：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果）。

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。即当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

我们看下getInstance()方法，调用的是SingleTonHoler.INSTANCE，取的是SingleTonHoler里的INSTANCE对象，跟上面那个DCL方法不同的是，getInstance()方法并没有多次去new对象，故不管多少个线程去调用getInstance()方法，取的都是同一个INSTANCE对象，而不用去重新创建。当getInstance()方法被调用时，SingleTonHoler才在SingleTon的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建，然后再被getInstance()方法返回出去，这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢？

---

在《深入理解JAVA虚拟机》中，有这么一段话:

虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步(<clinit>()类构造器方法：对类的静态变量和静态代码块进行初始化)，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。如果在一个类的<clinit>()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执行<clinit>()方法后，其他线程唤醒之后不会再次进入<clinit>()方法。同一个加载器下，一个类型只会初始化一次。)，在实际应用中，这种阻塞往往是很隐蔽的。

---

这个实现思路中最主要的一点就是利用类中静态变量的唯一性。

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

枚举

是否 Lazy 初始化：否

是否多线程安全：是

描述：这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

通过 SingleTon.INSTANCE 这条命令便可以实现调用。