一篇文章搞懂单例模式

一.定义

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

二.单例模式的八种方式

1.饿汉式（静态常量）

（1）步骤

①构造器私有化
②类的内部创建对象
③向外暴露一个静态的公共方法：getInstance

（2）具体代码

public class Singleton {
    //1.构造方法私有化
    private Singleton(){}

    //2.本类内部创建对象实例
    private final static Singleton singleton = new Singleton();

    //3.对外提供获得对象的方法
    public static Singleton getInstance(){
        return singleton;
    }
}

（3）优点

写法比较简单，在类装载的时候就完成实例化，避免了线程同步问题

（4）缺点

在类装载的时候就完成实例化，没有达到懒加载的效果。如果从始至终都没有使用过这个实例，则会造成内存的浪费

这种方式基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就有点早了，因为有可能用不到。

（5）结论

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

2.饿汉式（静态代码块）

（1）代码示例

public class Singleton {
    //1.构造方法私有化
    private Singleton(){}

    //2.本类内部创建对象实例
    private static Singleton singleton;
    
    //3.在静态代码块中实例化
    static {
        singleton = new Singleton();
    }

    //4.对外提供获得对象的方法
    public static Singleton getInstance(){
        return singleton;
    }
}

（2）评价

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

（3）结论

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

3.懒汉式（线程不安全的）

（1）具体代码

public class Singleton {
    //1.构造方法私有化
    private Singleton(){}

    //2.本类内部创建对象实例
    private static Singleton singleton;

    //3.对外提供获得对象的方法
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

（2）评价

起到了懒加载的效果，但是只能在单线程下使用

（3）结论

在实际开发中，不要使用这种方式

4.懒汉式（线程安全的）

（1）具体代码

public class Singleton {
    //1.构造方法私有化
    private Singleton(){}

    //2.本类内部创建对象实例
    private static Singleton singleton;

    //3.对外提供获得对象的方法
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

（2）优点

解决了线程不安全问题

（3）缺点

效率太低了，每个线程在想获得类的实例的时候，执行getInstance（）方法都要进行同步，而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。

（4）结论

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

5.懒汉式（双重检查）

（1）具体代码

public class Singleton {
    //1.构造方法私有化
    private Singleton(){}

    //2.本类内部创建对象实例
    private static Singleton singleton;

    //3.对外提供获得对象的方法
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class) {
                if(singleton == null) {//如果没有这个if，就不能用，是错的
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

（2）评价

Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if(singleton == null)检查，这样就可以保证线程安全了。
不仅实现了懒加载的效果，而且保证了线程安全，效率较高

（3）结论

开发中推荐使用这种单例设计模式

6.静态内部类

（1）具体代码

public class Singleton {
    //1.构造方法私有化
    private Singleton(){}

    //2.内部类内部创建对象实例
    private static class SingletonInstance{
        private static final Singleton singleton = new Singleton();
    }

    //3.对外提供获得对象的方法
    public static Singleton getInstance(){
        return SingletonInstance.singleton;
    }
}

（2）评价

在外部类进行类装载的时候，静态内部类并不会进行装载。这样保证了内存不会浪费。再一个，当内部类进行类装载的时候是线程安全的。
所以线程安全，而且利用了静态内部类的特点实现了懒加载，效率高

（3）结论

在开发中推荐这种方式

7.枚举

（1）具体代码

enum Singleton2{
    INSTANCE;
    public void sayOK(){
        System.out.println("OK");
    }
}
public class Main {
    public static void main(String[] args) {
        Singleton2 instance = Singleton2.INSTANCE;
        Singleton2 instance1 = Singleton2.INSTANCE;

        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
        /*
        true
        2129789493
        2129789493
         */
    }
}

（2）评价

不仅能避免多线程问题，而且还能方式反序列化重新创建新的对象。

（3）结论

开发中推荐使用

三.单例模式应用场景

1.需要频繁的进行创建和销毁的对象

2.创建对象时耗时过多或耗费资源过多（如重量级对象）

3.工具类对象

4.频繁访问数据库或文件的对象（如数据源、session工厂等）

5.经常使用到的对象