单例模式

tim-qtp2025年3月12日...大约 12 分钟设计模式

说到volatile的防止指令重排，那么volatile的内存屏障在哪里使用的最多，就是单例模式了。

那什么是单例模式，为什么需要单例模式？

单例模式就是在一个时域，一个类只有一个对象；因为有的类的实例对象，创建和销毁对于资源来说消耗不大，比如String；有的类比较庞大和复杂，如果频繁的创建和销毁对象，并且这些对象完全是可以复用的，那么将会造成一些不必要性能浪费；

举个例子，我要写一个访问数据库的demo，而创建数据库链接对象是一个耗费资源的操作；并且数据库链接完全是可以复用的，那么我就可以将这个类设计成到单例的，这样我只需要创建一次并重复使用对象就可以了；而不需要每次都访问数据库去创建一个链接对象，如果那么做将会是一个非常恐怖的事情；

1）饿汉式

饿汉式的问题：可能会浪费内存
饿汉式一上来就会把所有的东西加载到内存，对象就已经存在了，对象没有使用的话，可能会浪费内存

主要特点有：

构造函数私有，避免在外部被创建对象
提前创建好对象
提供公有的接口，返回在类内部提前创建好的对象
静态变量随着类的加载就已经实例化了，跟是否调用静态方法没有关系
饿汉式加载时就会初始化，懒汉式只有在获取单例的时候才会初始化
类加载时，成员变量会被初始化，局部变量不会

/**
 * 饿汉式单例
 */
public class Hungry {

    /**
     * 可能会浪费空间
     */
    private byte[] data1=new byte[1024*1024];
    private byte[] data2=new byte[1024*1024];
    private byte[] data3=new byte[1024*1024];
    private byte[] data4=new byte[1024*1024];


    private Hungry(){}
    
    private final static Hungry hungry = new Hungry(); //静态变量，类加载时就会被初始化

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

2）懒汉式

针对饿汉式单例的浪费内存的问题，提出了懒汉式单例，要用的时候再创建对象

public class LazyMan {
    
    private static LazyMan lazyman;//还没有创建对象，只是声明，没有new
    
    private LazyMan(){}
    
    public static LazyMan getInstance()
    {
      if(lazyman==null)
       {
         lazyman=new LazyMan();//如果这个对象为空，就实例化这个对象
       }
      return lazyman;
    }
}

在多个线程的情况下，懒汉式单例可能会出现安全问题，就是线程1进入了if判断，并开始构造对象

public class LazyMan {
  
    private static LazyMan lazyman;//还没有创建对象，只是声明，没有new
    
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    public static LazyMan getInstance()
    {
      if(lazyman==null)
       {
         lazyman=new LazyMan();//如果这个对象为空，就实例化这个对象
       }
      return lazyman;
    }

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

可以看到，有3个线程调用了构造函数，这说明程序中现在有3个Lazyman对象，就不是单例了，所以不安全

双重锁机制

public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static LazyMan lazyman;//还没有创建对象，只是声明，没有new

    public static LazyMan getInstance()
    {
        //双重检测锁模式 DCL
        if(lazyman==null)
        {
            //如果为空，先上一层锁，锁LazyMan当前对象
            synchronized (LazyMan.class){//静态方法是类锁
              //如果synchronized直接写在方法上，所有线程都要抢锁，效率低，这个只有为空时才会抢锁
                if(lazyman==null)//在锁里面再判断一次
                {
                    lazyman=new LazyMan();//如果这个对象为空，就实例化这个对象
                }
            }
        }

      return lazyman;
    }

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

        }
    }
}

提示

如果synchronized直接写在方法上，所有线程都要抢锁，效率低，这个只有为空时才会抢锁

可以看到只创建了一个对象

但是还是有可能出现问题

创建对象的过程在极端情况下肯定是会出现问题的，因为不是原子性操作，会经历

分配内存空间，
执行构造方法（初始化对象），
把对象指向分配的空间

但是可能会发生指令重排，可能会按132的顺序执行，就是先分配内存空间，然后用空对象先占用内存空间，占用之后再执行构造方法

如下图，很有可能A执行了13还没执行2，但是现在lazyman已经不是null了，如果现在进来一个B线程，外层判断不为空，那么B线程会直接返回lazyman，但lazyman实际上还没有完成构造，所以不安全（new只是把应用加上了，但是堆还没有创建完，return就会有问题）

所以要用volatile修饰防止指令重排（防止第二个线程抢先执行，抢先返回一个尚未初始化完成的引用）
所以这里是同步代码块保证了操作的原子性，volatile禁止了指令重排
指令重排的原理是为了提升CPU多段流水的效率，但并不是指令任意重排，处理器必须能正确处理指令依赖关系保障程序得出正确的执行结果。

总结：synchronized保证的是if判断和new一个对象能同时成功或同时失败，但是new一个对象不是原子操作，执行13后，第二个线程认为已经new对象成功了，最上面的if判断不等于null

3）静态内部类

在一个类里面写一个静态的类
首先只要单例一定要将构造器私有（外部代码无法直接调用构造函数来创建对象，只能通过 getInstance() 方法获取单例对象。）
加载外部类时，不会加载静态内部类 (由于单例对象 holder是在静态内部类InnerClass中初始化的，因此只有当第一次调用getInstance() 方法时，InnerClass 才会被加载) 线程安全且懒加载 (由于单例对象的初始化发生在静态内部类的加载阶段，而类加载是由 JVM 保证线程安全的（即同一个类只会被加载一次），因此静态内部类单例是线程安全的。) 但是静态内部类单例也是不安全的，因为反射可以破坏单例

//静态内部类
public class Holder {
    private Holder(){}
    
    public static Holder getInstance(){
        return InnerClass.holder;
    }
    
    public static class InnerClass{
        private static final Holder holder = new Holder();
    }
}

测试

public class Holder {
    private Holder() {
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    public static Holder getInstance() {
        return InnerClass.HOLDER;
    }

    public static class InnerClass {
        private static final Holder HOLDER = new Holder();
    }

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

可以看到，内存中只有一个实例，就是只有一个线程进入了构造函数，因为静态类只加载一次

但是只要有反射，任何私有的都是纸老虎，我们以DCL的单例为例，来试试反射

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//             LazyMan.getInstance();
//              //  System.out.println(LazyMan.getInstance());
//            }).start();
    //    }
        LazyMan instance = LazyMan.getInstance();
        //获得空参构造器
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        LazyMan lazyMan = declaredConstructor.newInstance();

        //测试两个对象是否一样
        System.out.println( instance );
        System.out.println(lazyMan);
    }

可以破解：

private LazyMan(){
    synchronized (LazyMan.class){

        if(lazyman!=null)
        {
            throw new RuntimeException("不要试图通过反射破坏单例");
        }
        System.out.println(Thread.currentThread().getName()+"ok");

    }
}

相当于在DCL的基础上又在构造函数里面加了一重检测

public class LazyMan {

    private LazyMan() {
        synchronized (LazyMan.class) {

            if (lazyman != null) {
                throw new RuntimeException("不要试图通过反射破坏单例");
            }
            System.out.println(Thread.currentThread().getName() + "ok");
        }
        //
    }

    private static volatile LazyMan lazyman;//还没有创建对象，只是声明，没有new

    public static LazyMan getInstance() {
        //双重检测锁模式 DCL
        if (lazyman == null) {
            //如果为空，先上一层锁，锁LazyMan当前对象
            synchronized (LazyMan.class) {//静态方法是类锁
                //如果synchronized直接写在方法上，所有线程都要抢锁，效率低，这个只有为空时才会抢锁
                if (lazyman == null)//在锁里面再判断一次
                {
                    lazyman = new LazyMan();//如果这个对象为空，就实例化这个对象
                }
            }
        }

        return lazyman;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//             LazyMan.getInstance();
//              //  System.out.println(LazyMan.getInstance());
//            }).start();
        //    }
        LazyMan instance = LazyMan.getInstance();
        //获得空参构造器
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        LazyMan lazyMan = declaredConstructor.newInstance();

        //测试两个对象是否一样
        System.out.println(instance);
        System.out.println(lazyMan);
    }
}

现在我们不用getInstance()去获取对象，而是直接通过反射创建两个对象

可以发现，单例又被破坏了，因为构造函数里面判断的是

 if (lazyman == null)//在锁里面再判断一次
                {
                }

但是注意，我们用反射new 的对象跟类里面的lazyman对象肯定是不一样的啊，没有调用getInstance(),类里面的lazyman就一直为空，所以单例又被破坏了

解决方法，用个标志位

private static boolean flag=false;
    private LazyMan() {
        synchronized (LazyMan.class) {

            if( flag==false)
            {
                flag=true;
            }
            else
            {
                throw new RuntimeException("不要试图通过反射破坏单例");
            }
        }
    }
}

来我们继续破坏单例，我们把这个flag字段给它破坏了

  Field  flag=LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        LazyMan lazyMan = declaredConstructor.newInstance();
        flag.set(lazyMan,false);//把第一个对象的flag重新改成false
        LazyMan lazyMan2 = declaredConstructor.newInstance();

        //测试两个对象是否一样
       // System.out.println(instance);
        System.out.println(lazyMan);
        System.out.println(lazyMan2);

可以发现单例又被破坏了。。。。

public class LazyMan {
private static boolean flag=false;
    private LazyMan() {
        synchronized (LazyMan.class) {

            if( flag==false)
            {
                flag=true;
            }
            else
            {
                throw new RuntimeException("不要试图通过反射破坏单例");
            }
        }
    }

    private static volatile LazyMan lazyman;//还没有创建对象，只是声明，没有new

    public static LazyMan getInstance() {
        //双重检测锁模式 DCL
        if (lazyman == null) {
            //如果为空，先上一层锁，锁LazyMan当前对象
            synchronized (LazyMan.class) {//静态方法是类锁
                //如果synchronized直接写在方法上，所有线程都要抢锁，效率低，这个只有为空时才会抢锁
                if (lazyman == null)//在锁里面再判断一次
                {
                    lazyman = new LazyMan();//如果这个对象为空，就实例化这个对象
                }
            }
        }
        return lazyman;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//             LazyMan.getInstance();
//              //  System.out.println(LazyMan.getInstance());
//            }).start();
        //    }
        // LazyMan instance = LazyMan.getInstance();
//获得空参构造器

        Field  flag=LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        LazyMan lazyMan = declaredConstructor.newInstance();
        flag.set(lazyMan,false);//把第一个对象的flag重新改成false
        LazyMan lazyMan2 = declaredConstructor.newInstance();

        //测试两个对象是否一样
       // System.out.println(instance);
        System.out.println(lazyMan);
        System.out.println(lazyMan2);
    }
}

那怎么解决呢？我们点进去反射的newInstance()看看呢

我们可以看到，如果类是一个枚举类型的话，就会告诉你不能使用反射破坏枚举，枚举是jdk 1.5 开始出现的，自带单例模式

4）枚举

枚举本身也是一个类

public enum EnumSingle {
    INSTANCE;
    public static EnumSingle getInstance(){
       return INSTANCE;
    }
}
 class Test{
     public static void main(String[] args) {
         EnumSingle  instance1=EnumSingle.INSTANCE;
         EnumSingle  instance2=EnumSingle.INSTANCE;
         EnumSingle  instance3=EnumSingle.getInstance();
         System.out.println( instance1);
         System.out.println( instance2);
         System.out.println( instance3);
     }
 }

我们来试试用反射破坏枚举单例

public enum EnumSingle {
   INSTANCE;
   public static EnumSingle getInstance()
   {
       return INSTANCE;
   }
 }
 class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
		EnumSingle  instance1=EnumSingle.INSTANCE;
//         EnumSingle  instance2=EnumSingle.INSTANCE;
//         EnumSingle  instance3=EnumSingle.getInstance();

         Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
         declaredConstructor.setAccessible(true);//先把构造器的私有权限破除，使得反射可以访问，创建对象
         EnumSingle instance2= declaredConstructor.newInstance();
         System.out.println( instance1);
         System.out.println( instance2);
     }
 }

下面的错误提示是枚举类没有空参的构造方法
也就是下面这句话出错了idea骗了我们

 Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);

正常破坏单例是应该报错不能使用反射破坏枚举

通过反编译我们可以看到，这个枚举本身也是一个class，它继承了一个枚举类
然而构造器还是空参的啊，说明我们还是被骗了

现在我们用jad.exe反编译试试

我们把class字节码生成java文件看看

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   EnumSingle.java

package juc.single;


public final class EnumSingle extends Enum
{

    public static EnumSingle[] values()
    {
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(juc/single/EnumSingle, name);
    }

    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public static EnumSingle getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
            INSTANCE
        });
    }
}

可以看到，不是无参构造器哦，而是有参构造器，有一个String,一个Int

现在我们修改反射代码

Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);

得到我们想要的结果了，抛出反射不能破坏枚举的单例异常

public enum EnumSingle {
    INSTANCE;
   public static EnumSingle getInstance()
   {
       return INSTANCE;
   }
}
 class Test{
     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
         EnumSingle  instance1=EnumSingle.INSTANCE;
//         EnumSingle  instance2=EnumSingle.INSTANCE;
//         EnumSingle  instance3=EnumSingle.getInstance();

        // Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
         Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
         declaredConstructor.setAccessible(true);//先把构造器的私有权限破除，使得反射可以访问，创建对象
         EnumSingle instance2= declaredConstructor.newInstance();
         System.out.println( instance1);
         System.out.println( instance2);
     }
 }

5）单例模式应用

服务和组件：在Spring Boot中，服务（Services）、组件（Components）、控制器（Controllers）等都是以单例模式存在的。这些Bean在应用的生命周期中只被实例化一次，并且在整个应用中共享。
配置类：配置类（使用@Configuration注解的类）也是单例的，它们负责配置和初始化项目中使用的Bean。避免了配置信息的不一致性。

单例模式

# 1）饿汉式

# 2）懒汉式

# 双重锁机制

# 3）静态内部类

# 4）枚举

1）饿汉式

2）懒汉式

双重锁机制

3）静态内部类

4）枚举