设计模式-单例模式

单例模式

单例模式：保证内存中的对象只存在一个，节省内存空间。
单例模式分为饿汉式和懒汉式，实际上就是一些吹毛求疵的大佬搞出来的，大多数时候饿汉式就满足需求，饿汉式：类初始化的时候就实例化加载到内存中，不管后续会不会用到（用不到我写他干嘛），与之相对的就是懒汉式，一些人认为，初始化就加载到内存中是不合理的，只有用到的时候才应该对其进行初始化。

饿汉式

类初始化的时候就实例化加载到内存中，不管后续会不会用到（用不到我写他干嘛）

/**
 * 饿汉式
 * 类加载到内存后 就实例化一个单例
 * 不管是否会使用到都会加到内存中
 */
public class Hangry {

    private static final Hangry INSTANCE = new Hangry();

    private Hangry(){}

    public static Hangry getInstance(){
        return INSTANCE ;
    }


}

懒汉式

只有当类被使用的时候才进行初始化

实现一

/**
 * 懒汉式
 *当类被使用到的时候才进行初始化
 *
 */
public class Lazy01 {

    private static Lazy01 INSTANCE;

    private Lazy01(){}

    public static Lazy01 getInstance(){
        if(INSTANCE == null){
            synchronized (Lazy01.class){
                if(INSTANCE == null){
                    INSTANCE = new Lazy01();
                }
            }

        }

        return INSTANCE ;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Lazy01.getInstance());
            }).start();
        }
    }

}

实现二

个人比较喜欢这种写法。。。

/**
 * 懒汉式
 *当类被使用到的时候才进行初始化
 *通过内部类的方式 内部类不会随着类加载而加载，只有被用到的时候才会加载 JVM规定类只会被加载一次 所以保证单例
 */
public class Lazy02 {

    private Lazy02(){}

    private static class Lazy02Holder{
        private final static Lazy02 INSTANCE = new Lazy02();
    }

    public static Lazy02 getInstance(){
        return Lazy02Holder.INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Lazy02.getInstance());
            }).start();
        }
    }

}

枚举单例

枚举就是单例的，还可以防止反序列化。

public enum Mgr {

    INSTANCE;

}