单例设计模式

最新推荐文章于 2024-09-16 10:31:05 发布

weixin_53184069

最新推荐文章于 2024-09-16 10:31:05 发布

阅读量317

点赞数 1

文章标签：单例模式 java c++

本文链接：https://blog.csdn.net/weixin_53184069/article/details/121886893

版权

本文详细探讨了Java中的单例设计模式，包括如何在多线程环境中保证单例的唯一性，以及不同实现方式的优缺点。重点介绍了双重检查锁定(DCL)优化的懒汉模式、静态内部类实现、枚举单例和饿汉模式。同时，还提到了反射攻击以及如何防止，强调了单例模式在资源管理和线程安全上的作用。

摘要由CSDN通过智能技术生成

单例设计模式

多线程环境下如何保证系统中只有一个实例

类实现序列化时如何保证

不能通过反射创建新的实例

懒汉模式

延迟加载，只有在真正使用的时候，才开始实例化

是一个double check 加锁优化
线程安全
编译器(JIT),CPU有可能对指令进行重排序，导致使用到尚未初始化的实例，可以通过添加volatile关键字进行修饰，对于volatile修饰的字段，可以防止指令重排
都可以通过反射创建多个实例因为newInstance()直接给构造器new对象
解决一个全局使用的类，频繁创建和销毁。拥有对象的唯一性，并保证内存中对象的唯一。可以节省内存，因为单例共用一个实例，有利于Java的垃圾回收机制。
也就是控制资源使用，通过线程同步来控制资源的并发访问
控制实例产生的数量，达到节约资源的目的；

单null检查

public class Singleton2 {
    private static Singleton2 instance;
    private Singleton2() {
    }

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

同步代码块

  public static Singleton2 getInstance() {
        if (instance == null) {
            synchronized (Singleton2.class) {
                instance = new Singleton2();
            }
        }
        return instance;
    }

同步方法

public class Singleton3 {
    private static Singleton3 instance;
    private Singleton3() {
    }
    public static synchronized Singleton3 getInstance() {
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }

double check

public class LazySingletonTest {
    public static void main(String[] args) {

        //单线程
       /* LazySingleton instance = LazySingleton.getInstance();
        LazySingleton instance1 = LazySingleton.getInstance();
        System.out.println(instance == instance1);*/
        //多线程
        new Thread( ()->{
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        } ).start();
        new Thread( ()->{
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        } ).start();
       /* new Thread(new Runnable() {
            @Override
            public void run() {

            }
        });*/
    }
}

class LazySingleton{
    private  static LazySingleton instance;
    private LazySingleton(){

    }

    public static LazySingleton getInstance(){
        if(instance == null){
           synchronized (LazySingleton.class){
               if(instance == null) {
                   instance = new LazySingleton();
                   //字节码层
                   //JIT    CPU    有可能对如下指令进行重排序
                   //1 分配空间
                   //2 初始化
                   //3 引用赋值

                   //如重排序后的结果为如下
                   //1 分配空间
                   //3 引用赋值
                   //2 初始化
               }
           }
        }
        return instance;
    }
}

第一重check为了提高访问性能。因为一旦实例被创建，所有的check永远为假。把第一重check去掉也没问题，只是访问性能降低了，那样就变成和直接同步方法一样了。
第二重check是为了线程安全，确保多线程环境下只生成一个实例。第一重ckeck可以被多个线程进入，但是第二重check却只能排队进入

重排序后: 有可能第一个线程进去了并且引用赋值了，那么instance就不为空了，则第二个线程就可以进去但是同时第一个线程可能还没有初始化，从而导致空指针的问题

volatile ：这个关键字放在instance的声明前面可以防止instance这个指令码重排序，从而有效的解决问题

静态内部类

线程安全的，也是懒汉式的

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author WJR
 * @create 2021-12-10 21:52
 */
public class InnerClassSingletonTest {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
     /*   InnerClassSingleton instance = InnerClassSingleton.getInstance();
        InnerClassSingleton instance1 = InnerClassSingleton.getInstance();
        System.out.println(instance == instance1);*/

     /*   new Thread( ()->{
            InnerClassSingleton instance = InnerClassSingleton.getInstance();
            System.out.println(instance);
        }).start();
        new Thread( ()->{
            InnerClassSingleton instance = InnerClassSingleton.getInstance();
            System.out.println(instance);
        }).start();*/
        
        //反射攻击
        Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();
        InnerClassSingleton instance = InnerClassSingleton.getInstance();
        System.out.println(innerClassSingleton == instance);
    }
}
class InnerClassSingleton{
    private static class InnerClassHolder{
        private final static InnerClassSingleton instance = new InnerClassSingleton();
    }

    public InnerClassSingleton() {
        /*
        if(InnerClassHolder.instance != null){
            throw new RuntimeException("单例不允许多个实例");
        }
        */
    }
    //掉方法并且返回值的时候才会初始化new InnerClassSingleton();
    public static InnerClassSingleton getInstance(){
        return InnerClassHolder.instance;
    }
}

@CallerSensitive
public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
           IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, null, modifiers);
        }
    }
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)/
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}

上述代码说明在 (clazz.getModifiers() & Modifier.ENUM) ！= 0 时也不能获取反射

enum反射攻击测试

import java.lang.reflect.Constructor;

/**
 * @author WJR
 * @create 2021-12-10 22:04
 */
public enum enumsingleton {
    INSTANCE;

}
//访问就报错
class EnumTest{
    public static void main(String[] args) throws NoSuchMethodException {
 /*     enumsingleton instance = enumsingleton.INSTANCE;
        enumsingleton instance1 = enumsingleton.INSTANCE;
        System.out.println(instance == instance1);*/
    Constructor<enumsingleton> declaredConstructor = enumsingleton.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        enumsingleton instance = declaredConstructor.newInstance("INSTANCE", 0);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4OupwjQa-1639289665686)(C:\Users\吴金融\AppData\Roaming\Typora\typora-user-images\image-20211211142415829.png)]

双shift 搜索java.lang.Enum

protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

所以两个参数

饿汉模式

类加载的初始化阶段就完成了实例的初始化。本质上就是借助于jvm类加载机制，保证实例的唯一性（初始化过程只会执行一次）及线程安全（JVM以同步的形式来完成类加载的整个过程）。

类加载过程：

加载二进制数据到内存中，生成对应的Class数据结构，
连接：a.验证，b.准备（给类的静态成员变量赋默认值），c.解析
初始化：给类的静态变量赋初值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F9eSo9V2-1639289665691)(C:\Users\吴金融\AppData\Roaming\Typora\typora-user-images\image-20211210223144403.png)]

静态常量

在类加载时候就创建了实例，属于饿汉模式。其是线程安全的，但是有一个缺点，可以通过反射创建新的实例

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

    private Singleton1() {
    }
    
    public static Singleton1 getInstance(){
        return INSTANCE;
    }
}