JAVA创建型模式--单例模式

一、引言

  今天是22年的8月份，没工作的我每天都会焦虑 ，可能这就是因为穷吧 ~

  好了，言归正常，今天我们学习下单例模式~

二、什么是单例模式 ？

单例模式是Java23种设计模式的之一，属于创建型模式。

单例模式顾名思义就是在整个运行时域，一个类只有一个实例，并且提供一个全局访问点。

三、那为什么需要单例模式呢 ？

        因为有的类型的实例对象的创建和销毁对资源来说消耗不大，有的类型呢，比较庞大和复杂，如果频繁创建和销毁对象，并且这些对象是完全可以复用的，那就会造成一些不必要的性能浪费。

四、单例模式--饿汉式

   饿汉式：顾名思义比较饿，不管你用不用得上，一开始就创建这个单例对象

/**
 * @Author WangYan
 * @Date 2022/6/14 20:43
 * @Version 1.0
 * 饿汉式单例:不管你用不用得上,一开始就创建这个单例对象。
 *
 * 三个要素:
 *   1.私有的构造方法,防止外部new
 *   2.指向自己实例的私有静态引用
 *   3.以自己为实例返回值的静态公用方法
 *
 * 缺点: 可能会浪费空间
 *
 * 线程安全的,在类创建的同时就已经创建好了一个静态的对象提供使用,以后不再改变
 * */
public class Hungry {

    private Hungry(){
        System.out.println("kkt");
    }

    public static final Hungry hungry = new Hungry();

    public static Hungry getInstance(){
        return hungry;
    }
}

五、单例模式--懒汉式(线程不安全的)

懒汉式：  在真正用得到的时候才去创建这个单例对象

/**
 * @Author WangYan
 * @Date 2022/8/13 21:19
 * @Version 1.0
 * 懒汉式单例:真正用的到时候才去创建单例对象
 */
public class Lazy {

    // 1.私有构造方法
    private Lazy(){
    }

    // 2.以自己为实例的静态引用
    private static Lazy lazy = null;

    // 3.提供一个全局的访问点
    public static Lazy getInstance(){
        // 如果这里是多线程，就会出现线程安全问题
        if (lazy == null){
            lazy = new Lazy();
        }

        return lazy;
    }
}

六、单例模式--DCL 懒汉式（双重检查模式）

DCL懒汉式：保证了懒汉式的线程安全，在项目中比较常用。

/**
 * @Author WangYan
 * @Date 2022/6/14 20:55
 * @Version 1.0
 * 懒汉式单例:真正用的到时候才去创建单例对象
 *
 *  三个要素点:
 *  1.定义一个私有构造方法
 *  2.指向自己的实例私有静态引用,为空
 *  3.定义一个以自己为返回值的静态的公有方法,判断静态自己的实例是否为空,为空才去创建对象
 *
 *  在多线程的情况下,如果在创建对象不加synchronized,则会导致对对象的访问是线程不安全的。
 */
public class Lazy {
    private Lazy(){
        System.out.println("kkt");
    }

    public volatile static Lazy lazy = null;

    private static Lazy getInstance(){
        /**
         * 双重检测锁模式的 懒汉式单例 简称: DCL懒汉式
         * 存在的问题:
         *   1.new对象的时候,不是原子性操作,可能会导致底层创建对象的时候顺序错乱。(简称: 指令重排)
         * 解决办法:
         *  1.volatile  双重检测锁
         */
        if (lazy == null){
            synchronized (Lazy.class){
                if (lazy == null){
                    lazy = new Lazy(); // 不是原子性操作
                    /**
                     * 执行的顺序:
                     * 1.分配内存空间
                     * 2.执行构造方法,初始化对象
                     * 3.把初始化对象指向分配的内存空间
                     */
                }
            }
        }

        return lazy;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Lazy.getInstance();
            }).start();
        }
    }
}

七、单例模式--静态内部类的实现

 静态内部类：可以完美的实现懒加载，不会有线程问题，比较推荐！！

/**
 * @Author WangYan
 * @Date 2022/6/27 17:28
 * @Version 1.0
 * 懒汉式 - 静态内部类
 * 优点:
 *   1.静态内部类加载的时候,是不会加载的,实现了懒加载的特性
 *   2.在调用获取实例方法的时候,会去装载内部类,在jvm装载类的时候线程是安全的,静态属性只会在装载类初始化一次。
 */
public class InnerClass {

    // 私有构造,防止外部new
    private InnerClass(){
    }

    // 创建静态内部类,提供常量
    private static class SingletonInstance {
        private static final InnerClass inner = new InnerClass();
    }

    // 给外部提供实例获取方法
    public static InnerClass getInstance(){
        return SingletonInstance.inner;
    }
}

八、单例模式--枚举实现

枚举：解决线程同步、防止序列化，也是比较推荐使用的，但是在项目用到的比较少！！

/**
 * @Author WangYan
 * @Date 2022/8/13 23:03
 * @Version 1.0
 *
 * 单例模式 懒汉式 - 枚举实现
 *
 * 优点: 解决线程同步、防止反序列化，非常完美!
 */
public class EnumSingle {

    // 1.私有构造
    private EnumSingle(){
    }

    // 2.指向自己实例的私有静态引用
    private enum Single{
        INSTANCE;

        private EnumSingle enumSingle;

        // JVM保证这个方法只调用一次
        Single(){
            enumSingle = new EnumSingle();
        }

        public EnumSingle getInstance(){
            return enumSingle;
        }
    }

    // 3.以自己为实例返回值的静态公用方法
    public EnumSingle getSingle(){
        return Single.INSTANCE.enumSingle;
    }
}

总结

1.双重检查的方式是在项目中比较常用的

2.静态内部类可以完美实现懒加载

3.静态内部类、enum比较推荐使用

 拜拜~

有任何问题欢迎大家指出~

Thank You !