详解单例模式8种写法-一站式搞定面试官
01
单例模式简介
单例模式，采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得起对象实例的方法（静态方法）。
02
单例模式的使用场景
1.对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
2. 创建对象时耗时过多或者耗费资源过多，但是又经常要用到的对象、工具类对象、频繁访问数据库或文件的对象（如：数据源，session工厂等）
03
8种写法详解
//饿汉式--静态常量
public class Singleton01 {
//构造器私有化
private Singleton01(){}
private final static Singleton01 instance = new Singleton01();public static Singleton01 getInstance(){
return instance;
}
}
1
优点：简单，类装载的时候就完成实例化，避免了同步问题
2
缺点：这种方式基于classloader机制避免了多线程的同步问题，不过，instance在类装载的时候就实例化了，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果，也会导致内存浪费。
3
结论：可用，可能导致内存浪费
2 饿汉式二之静态初始化块
public class Singleton02 {
//构造器私有化
private Singleton02(){}
private static Singleton02 instance;
static{//在静态代码块中实例化
instance = new Singleton02();
}
public static Singleton02 getInstance(){
return instance;
}
}1
优点：与上一种相同
2
缺点：与上一种相同
3
结论：可用，可能导致内存浪费
3 懒汉式一之没有同步写法
public class Singleton03 {
//构造器私有化
private Singleton03(){}
private static Singleton03 instance;
public static Singleton03 getInstance() {
if(instance == null){
instance = new Singleton03();
}
return instance;
}
}1
优点：做到了lazy loading的效果。
2
缺点：不能在多线程中使用。
3
结论：不建议使用
4 懒汉式二之解决同步问题写法--同步getInstance()
public class Singleton04 {
//构造器私有化
private Singleton04(){}
private static Singleton04 instance;
public synchronized static Singleton04 getInstance() {
if(instance == null){
instance = new Singleton04();
}
return instance;
}
}1
优点：线程安全了
2
缺点：
效率太低了，因为每一次调用getInstance()都要进行同步。其实这个方法只执行一次实例化代码就可以了。后面想获得该类实例，直接return即可。
3
结论：不推荐使用
5 懒汉式三之解决性能问题写法--同步实例化部分代码
public class Singleton05 {
//构造器私有化
private Singleton05(){}
private static Singleton05 instance;
public static Singleton05 getInstance() {
if(instance == null){
synchronized(Singleton05.class){
instance = new Singleton05();
}
}
return instance;
}
}1
本意：提出这种方式本意是为了解决上面效率低的缺点
2
但是：同步失败了！
因为如果一个线程进入了if(instance == null)判断语句块，还没来得及往下执行，另一个线程也通过这个判断语句，这时便会产生多个实例。
3
结论：错误的写法，不推荐使用
6 双重校验Double check
public class Singleton06 {
//构造器私有化
private Singleton06(){}
private volatile static Singleton06 instance;
public static Singleton06 getInstance() {
if(instance == null){
synchronized (Singleton06.class){
if(instance == null){
instance = new Singleton06();
}
}
}
return instance;
}
}1
关于使用volatile：保证了指令重排序的问题，并且保证不会出现引用先生成了，但是堆还没初始化的情况，导致使用出错。（这一块详情可以看看JVM的类的加载）
2
优点：
1. 保证了线程同步问题。
2. 避免了反复进行同步方法。
3. 延迟加载，效率高
3
结论：推荐使用！
7 静态内部类
public class Singleton07 {
//构造器私有化
private Singleton07(){}
static class Holder{
private static final Singleton07 instance= new Singleton07();
}
public static Singleton07 getInstance() {
return Holder.instance;
}
}
1
机制：
1. 采用类装载的机制保证初始化实例时只有一个线程。
2. 静态内部类方式在Singleton类被加载时，并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载Holder类，从而完成Singleton的实例化。
3. 类的静态属性只会在第一次加载类的时候初始化，所以，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
2
优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高
3
结论：推荐使用！
8 枚举类
enum Singleton08 {
INSTANCE;
public void mothod(){
System.out.println("这是枚举类的方法！");
}
}//这里特地把主方法也展示一下，方便大家验证。
class Test08{
public static void main(String[] args) {
Singleton08 instance = Singleton08.INSTANCE;
Singleton08 instance1 = Singleton08.INSTANCE;
System.out.println(instance == instance1);
System.out.println(instance.hashCode());
System.out.println(instance1.hashCode());
instance.mothod();
}
}
1
优点：使用枚举类，不仅能够避免多线程同步问题，还能防止反序列化重新创建新的对象。
04
结论
1 使用推荐
结合上面的分析，可以得到：
所以小伙伴们知道应该重点学习哪几种单例模式的写法啦！
2 重温使用场景
1.对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
2. 创建对象时耗时过多或者耗费资源过多，但是又经常要用到的对象、工具类对象、频繁访问数据库或文件的对象（如：数据源，session工厂等）
别忘了点个在看哦！转发那就太好了！