概述

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例设计模式分类两种：

饿汉式：类加载就会导致该单实例对象被创建

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

结构

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

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

代码实现

饿汉式（静态变量）

package demo1;

/**
 * @author: ZQH
 * @project: Design Pattern
 * @description 饿汉式：静态成员变量
 * @date: 2023/7/18 0:05
 */
public class Singleton {

    // 1、私有的构造方法
    private Singleton(){};

    // 2、 内部实例化对象
    private static Singleton instance = new Singleton();

    // 3、外界访问
    public static Singleton getInstance(){
        return instance;
    }

}

PS：该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

饿汉式（静态代码块）

package demo2;

/**
 * @author: ZQH
 * @project: Design Pattern
 * @description 静态代码块
 * @date: 2023/7/18 0:27
 */
public class Singleton {
    // 1、私有构造
    private Singleton(){}

    // 2、创建单例空对象
    private static Singleton instance;

    // 3、 静态代码块
    static {
        instance = new Singleton();
    }

    // 4、对外暴露
    public static Singleton getInstance(){
        return instance;
    }

}

PS：该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

懒汉式（双重检查方式）

package demo3;

/**
 * @author: ZQH
 * @project: Design Pattern
 * @description 懒汉式（双重检查方式）
 * @date: 2023/7/18 13:29
 */
public class Singleton {

    // 私有构造
    private Singleton(){}

    // 创建实例 volatile 保证变量的可见性、有序性，避免出现编译器优化 。
    private static volatile Singleton instance;

    // 对外暴露，加同步锁是为了让线程之间对临界资源的互斥访问
    public static Singleton getInstance(){

        // 第一次判断，instance 如果不为null，不需要抢占锁，直接返回对象
        if(instance == null)
        {   // 第二次判断
            synchronized(Singleton.class){
                if (instance == null) instance = new Singleton();
            }
        }

        return  instance;
    }

}

PS：添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。