详解单例模式8种写法-一站式搞定面试官

Posted 2021-05-01 大树的编程之旅

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了详解单例模式8种写法-一站式搞定面试官相关的知识，希望对你有一定的参考价值。

点击上方蓝字关注我们

本文长度为 3189 字，建议阅读 8 分钟

单例模式简介

单例模式，采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得起对象实例的方法（静态方法）。

单例模式的使用场景

1.对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

2. 创建对象时耗时过多或者耗费资源过多，但是又经常要用到的对象、工具类对象、频繁访问数据库或文件的对象（如：数据源，session工厂等）

8种写法详解

1 饿汉式一之静态常量

//饿汉式--静态常量
public class Singleton01 {
    //构造器私有化
    private Singleton01(){}
    private final static Singleton01 instance = new Singleton01();    public static Singleton01 getInstance(){
        return instance;
    }
}

优点：简单，类装载的时候就完成实例化，避免了同步问题

缺点：这种方式基于classloader机制避免了多线程的同步问题，不过，instance在类装载的时候就实例化了，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果，也会导致内存浪费。

结论：可用，可能导致内存浪费

2 饿汉式二之静态初始化块

public class Singleton02 {
    //构造器私有化
    private Singleton02(){}
    private static Singleton02 instance;
    static{//在静态代码块中实例化
        instance = new Singleton02();
    }
    public static Singleton02 getInstance(){
        return instance;
    }
}

优点：与上一种相同

缺点：与上一种相同

结论：可用，可能导致内存浪费

3 懒汉式一之没有同步写法

public class Singleton03 {
    //构造器私有化
    private Singleton03(){}
    private static Singleton03 instance;
    public static Singleton03 getInstance() {
        if(instance == null){
            instance = new Singleton03();
        }
        return instance;
    }
}

优点：做到了lazy loading的效果。

缺点：不能在多线程中使用。

结论：不建议使用

4 懒汉式二之解决同步问题写法--同步getInstance()

public class Singleton04 {
    //构造器私有化
    private Singleton04(){}
    private static Singleton04 instance;
    public synchronized static Singleton04 getInstance() {
        if(instance == null){
            instance = new Singleton04();
        }
        return instance;
    }
}

优点：线程安全了

缺点：

效率太低了，因为每一次调用getInstance()都要进行同步。其实这个方法只执行一次实例化代码就可以了。后面想获得该类实例，直接return即可。

结论：不推荐使用

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;

    }
}

本意：提出这种方式本意是为了解决上面效率低的缺点

但是：同步失败了！

因为如果一个线程进入了if(instance == null)判断语句块，还没来得及往下执行，另一个线程也通过这个判断语句，这时便会产生多个实例。

结论：错误的写法，不推荐使用

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;
    }
}

关于使用volatile：保证了指令重排序的问题，并且保证不会出现引用先生成了，但是堆还没初始化的情况，导致使用出错。（这一块详情可以看看JVM的类的加载）

优点：

1. 保证了线程同步问题。

2. 避免了反复进行同步方法。
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. 采用类装载的机制保证初始化实例时只有一个线程。
2. 静态内部类方式在Singleton类被加载时，并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载Holder类，从而完成Singleton的实例化。
3. 类的静态属性只会在第一次加载类的时候初始化，所以，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高

结论：推荐使用！

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();
    }
}