java设计模式——创建者模式——单例设计模式

创建者模式——单例设计模式

单例模式概述：

单例模式是java中最简单的设计模式之一，这种类型的数据模式属于创建型模式，它提供了一种创建对象的最佳方法。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实力化该类的对象。

单例模式的结构

单例模式主要有以下角色：

• 单例类：只能创建一个实例的类。
• 访问类：用来使用单例类。

单例模式的实现

从总体上看，单例模式的实现方式可以分为饿汉式和懒汉式。饿汉式是指在类加载过程中就会导致单例模式对象被创建。懒汉式是指首次使用该类对象时才会创建。
饿汉式方式1——使用静态变量方式

/**
 * 饿汉式——静态变量
 */
public class Singleton1 {
    //将构造方法私有
    private Singleton1(){};

    //在成员位置创建该类的对象
    private static Singleton1 instance = new Singleton1();

    //对外提供静态方法获取该对象
    public static Singleton1 getInstance(){
        return instance;
    }   
}

在上述代码中将单例类的构造方法私有化，使得只有在单例类内可以调用构造方法创建单例对象。在单例类的成员变量位置，将单例类实例化。并在单例类中加入static静态方法getInstance，方法返回实例后的单例对象，使得外部类可以访问到单例对象。
对于上述单例模式的实现过程，也可以在成员变量位置只是声明内部变量，在静态代码块内将其实例化。
无论使用哪种饿汉式的单例模式实现方法，单例类都会在类加载过程中被实例化，无论在程序中是否应用了单例类中的方法或成员变量，实例后的单例对象都会一直存在于内存中，造成内存的浪费。
饿汉式方式2——枚举方式

public enum Singleton4 {
    instance;
}

枚举类实现单例模式是十分优美的简单的实现方式，因为枚举类是线程安全的，并且只会装载一次，所以可以利用枚举类实现单例模式。
懒汉式方式1——双重检查锁

public class Singleton2 {
    //将构造方法私有
    private Singleton2(){};

    private static Singleton2 instance;

    //对外提供静态方法获取对象
    public static Singleton2 getInstance(){
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(instance == null){
            synchronized (Singleton2.class){
                //抢到锁之后再次判断instance是否为null
                if (instance == null){
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}

使用懒汉式的实现方式，可以避免之前饿汉式中带来的内存浪费的问题。但是使用懒汉式存在新的问题，就是当多个线程同时调用getInstance方法时，有可能会实例出很多对象，如果将getInstance方法用synchronized关键字锁住，优惠造成性能上严重下降。双重检查锁很巧妙的解决了这个问题。
双重检查锁，在锁外部先进行一次判断，如果已经完成实例化，则不会进行锁争夺。在synchronized内有进行一次判断，防止在阻塞状态的线程得到锁后再次进行实例化操作。
懒汉式方式2——静态内部类方式

public class Singleton3 {
    //将构造方法私有化
    private Singleton3(){};
    
    //静态内部类
    private static class SingletonHolder{
        private static final Singleton3 instance = new Singleton3();
    }
    
    //对外提供静态方法获取该对象
    public static Singleton3 getInstance(){
        return SingletonHolder.instance;
    }
}

由于jvm特性，在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性或者方法被调用时才会被加载，并初始化静态属性。静态属性由于被static修饰，保证只被实例化一次，并且严格保证实例化顺序。
第一次加载Singleton3类时不会初始化instance，只有第一次调用getInstance方法，虚拟机加载SingletonHolder，并初始化instance，这样不仅能确保线程安全，也能保证Singleton3类的唯一性。

单例模式的优化

在单例模式中，通过“序列化-反序列化”的方式、“反射”的方式都可以破坏单例模式。为了解决反序列化问题，可以在单例类中加入readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则放回新new出来的对象。为了解决反射问题，可以在当调用私有构造方法时，如果单例类已经被实例化，则直接抛出异常。
解决反序列化与反射，以双重检查锁方式为例进行如下改进：

import java.io.Serial;
import java.io.Serializable;

public class Singleton2 implements Serializable {
    //将构造方法私有
    private Singleton2(){
    	//解决反射
        if(instance != null){
            throw new RuntimeException();
        }
    };

    private static Singleton2 instance;

    //对外提供静态方法获取对象
    public static Singleton2 getInstance(){
        //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if(instance == null){
            synchronized (Singleton2.class){
                //抢到锁之后再次判断instance是否为null
                if (instance == null){
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }

	//解决反序列化
    @Serial
    public Object readResolve(){
        System.out.println("===");
        return instance;
    }
}

文章内容为个人学习总结，如有错误望指正。
参考链接https://www.bilibili.com/video/BV1Np4y1z7BU