JAVA几种常见的单例模式实现

什么是单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。

• 某个类只能有一个实例：构造器私有化

• 这个类必须自行创建这个实例：含有一个该类的静态变量来保存这个唯一实例

• 这个类必须自行向系统提供这个实例：对外提供获取该实例的方法

  • （1）直接暴露
  • （2）用静态变量的get方法获取

单例模式分类

1. 饿汉式 ：类一加载就创建对象，不管你需要不需要；
   不会出现线程问题
2. 懒汉式：延迟创建这个对象，就是用到的时候才去创建；
   有线程安全问题

饿汉式举例

• 直接实例化饿汉式（简洁直观）

/**
 * 饿汉式
 * 直接创建这个对象，不管你需要不需要
 *
 * （1）构造器私有化
 * （2）自行创建并且用静态变量保存
 * （3）向外提供这个实例
 * （4）强调这是一个单例，用final修饰
 *
 */
public class Singleton1 {

    public static final Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){

    }

}

获取对象：Singleton1.INSTANCE得到一个Singleton1对象

• 枚举式

/**
 * 枚举类型：表示该类型的对象是有限的几个
 * 我们限定为一个就成了单例
 */
public enum Singleton2 {
    INSTANCE
}

使用枚举类来产生一个单例对象：Singleton2.INSTANCE

• 静态代码块

/**
 * 静态代码块的方式
 */
public class Singleton3 {

    public static final Singleton3 INSTANCE;

    // 类加载的时候直接执行
    static {
        INSTANCE = new Singleton3();
    }

    private Singleton3() {
    }
}

懒汉式举例

• 线程不安全适用于单线程

/**
 * 懒汉式
 * 延迟创建这个对象
 *
 * （1） 构造器私有化
 * （2） 用一个静态变量保存这个唯一实例
 *  (3) 提供一个静态方法获取对象
 *  (4) 线程不安全  适合单线程
 */
public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4() {

    }

    public static Singleton4 getInstance() {
        if (instance == null) {
            instance = new Singleton4();
        }
        return instance;
    }
}

• 双重检验（理论上线程安全）

public class Singleton5 {
    private static Singleton5 instance;

    private Singleton5() {

    }

    // 双重检验锁
    public static Singleton5 getInstance() {
        if (instance == null) {
            synchronized (Singleton5.class) {
                if (instance == null) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Singleton5();
                }
            }
        }

        return instance;
    }
}

• 静态内部类形式

/**
 * 懒汉式
 * 延迟创建这个对象
 *
 * 在内部类被加载和创建是才生成INSTANCE
 * 静态内部类不会随着外部类的加载和初始化而初始化，他是要单独加载的
 * 因为是内部类加载和初始化的，所以是线程安全的，适用于多线程
 */
public class Singleton6 {
    private Singleton6() {

    }

    private static class Inner{
        private static final Singleton6 instance = new Singleton6();
    }

    private static Singleton6 getInstance(){
        return Inner.instance;
    }
}

双重检验锁运行逻辑可以看一下这篇文章：[Java单例模式中双重检查锁(https://blog.youkuaiyun.com/qq646040754/article/details/81327933)