单例设计模式之——磨人的单例！嗯？这还是我认识的那个单例吗？

于 2023-03-30 16:08:55 发布
阅读量209 收藏
点赞数
分类专栏： 设计原则与设计模式 文章标签： 设计模式 java 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54194323/article/details/129859650
版权

磨人的单例！嗯？这还是我认识的那个单例吗？

各位看官里边请：

（摘要）做了这么多手段，真的就拿单例没办法了吗？(枚举大哥麻烦靠边点，小心误伤！)

看我暴力反射！！

看我序列化！
在这里插入图片描述

单例设计模式

单例设计模式是创建型模式其中之一，创建型模式的主要关注点是“怎样创建对象”，主要的特点是将对象的创建与使用分离，这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。

  • 单例模式
  • 工厂方法模式
  • 抽象工厂模式
  • 原型模式
  • 建造者模式

单例模式特点

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

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

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

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

在这里插入图片描述

1.1、懒汉式（线程不安全）

// 线程不安全
public class Singletons {
    // 私有构造方法
    private Singletons() {}

    // 在成员位置创建该类的对象
    private static Singletons instance;

    // 对外提供静态方法获取该对象
    public static Singletons getInstance() {

        if(instance == null) {
            instance = new Singletons();
        }
        return instance;
    }
}

由此可得：该方式在成员位置声明Singletons类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singletons类的对象的时候才创建Singletons类的对象，这样就实现了懒加载的效果。

但是，如果是多线程环境，会出现线程安全问题。

1.2、懒汉式（线程安全）

// 线程安全
public class Singletons {
    // 私有构造方法
    private Singletons() {}
    
    // 在成员变量位置创建该类的对象
    private static Singletons instance;
    
    // 对外提供静态方法获取该对象
    public static synchronized Singletons getInstance(){
        
        if(instance == null) {
            instance = new Singletons();
        }
        return instance;
    }
}

synchronized关键字：该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，同步之后导致该方法的执行效果特别低。

由此可见是在对象创建初始化的时候会出现线程安全问题，一旦对象创建完成则不会有线程安全问题。

1.3、懒汉式（双重检查锁）

提到加锁，不得不说到读与写，线程安全主要在于写操作，读操作则不会，所以我们可以再次调整加锁的时机。

由此，双重检查锁模式它来了。

public class Singletons { 

    // 私有构造方法
    private Singletons() {}
    
    /**
     * 给对象加上volatile关键字可以保证可见性和有序性
 	 * private static volatile Singleton instance;
 	 */
    private static Singletons instance;

   // 对外提供公共的方法获取该对象
    public static Singletons getInstance() {
		
        // 如果instance不为null，直接返回实例
        if(instance == null) {
            // 同步代码块
            synchronized (Singleton.class) {
                // 抢到锁之后再次判断是否为null
                if(instance == null) {
                    instance = new Singletons();
                }
            }
        }
        return instance;
    }
}

由此，单例、性能、线程安全问题都可以保证，但是在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

volatile 关键字可以解决这个问题，在上述代码成员变量中注释, volatile 关键字可以保证可见性和有序性。添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

1.4、懒汉式（静态内部类）

看我终极方式！！！

此方法有些取巧，但又完全符合规则，非常精致巧妙地处理了单例、性能、线程安全等等问题，各位看官请：

由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。

静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

public class Singletons {

    // 私有构造方法
    private Singletons() {}
    
    /**
     * 第一次加载Singleton类时不会去初始化INSTANCE，
     * 只有第一次调用getInstance，虚拟机加载SingletonHolder
     * 并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。
     */

    private static class SingletonHolder {
        private static final Singletons INSTANCE = new Singletons();
    }

    // 对外提供静态方法获取该对象
    public static Singletons getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

是吧！就是这么简单！

静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。

在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

在这里插入图片描述

2.1饿汉式（王炸！枚举方式）

枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

/**
 * 枚举方式
 */
public enum Singleton {
    INSTANCE;
}

就是这么简单粗暴！

2.2饿汉式（静态变量）

该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。

但是！如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 成员位置声明Singleton类型的静态变量
    private static Singleton instance = new Singleton();

    // 对外提供公共的方法获取该对象
    public static Singleton getInstance() {
        return instance;
    }
}

2.3饿汉式（静态代码块）

该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。

所以和饿汉式的静态变量方式基本上一样，该方式也存在内存浪费问题。

public class Singleton {

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

    // 成员位置声明Singleton类型的静态变量
    private static Singleton instance;

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

    // 对外提供公共的方法获取该对象
    public static Singleton getInstance() {
        return instance;
    }
}

你以为到这里就结束了吗？

不 不 不 ！！

做了这么多手段，真的就拿单例没办法了吗？(枚举大哥麻烦靠边点，小心误伤！)

看我暴力反射！！

看我序列化！

在这里插入图片描述

3.1破坏单例模式

怎么使得单例类（Singleton）可以创建多个对象，枚举方式除外。

注意：枚举方式不会有以下问题。

  • 反射

    Singleton类：

    public class Singleton {

    // 私有构造方法
    private Singleton() {}
    
    private static volatile Singleton instance;

    public static Singleton getInstance() {

        if(instance != null) {
            return instance;
        }

        synchronized (Singleton.class) {
            if(instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

    Test类：

    public class Test {
    public static void main(String[] args) throws Exception {
        // 获取Singleton类的字节码对象
        Class clazz = Singleton.class;
        // 获取Singleton类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor();
        // 取消访问检查
        constructor.setAccessible(true);

        // 创建Singleton类的对象Single1
        Singleton Single1 = (Singleton) constructor.newInstance();
        // 创建Singleton类的对象Single2
        Singleton Single2 = (Singleton) constructor.newInstance();

        // 判断通过反射创建的两个Singleton对象是否是同一个对象
        System.out.println(Single1 == Single2);
    }
}

    运行结果是false，成功破坏！

  • 序列化反序列化

    Singleton类：

    public class Singleton implements Serializable {

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

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

    Test类：

    public class Test {
    public static void main(String[] args) throws Exception {
        // 往文件中写对象
        // writeObject2File();
        // 从文件中读取对象
        Singleton Single1 = readObjectFromFile();
        Singleton Single2 = readObjectFromFile();

        // 判断两个反序列化后的对象是否是同一个对象
        System.out.println(Single1 == Single2);
    }

    private static Singleton readObjectFromFile() throws Exception {
        // 创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\t.txt"));
        // 第一个读取Singleton对象
        Singleton instance = (Singleton) ois.readObject();

        return instance;
    }

    public static void writeObject2File() throws Exception {
        // 获取Singleton类的对象
        Singleton instance = Singleton.getInstance();
        // 创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\t.txt"));
        // 写出到文件中
        oos.writeObject(instance);
    }
}

    运行结果是false，成功破坏！

3.2解决问题

  • 序列化、反序列方式解决方法

    Singleton类中添加readResolve()方法，在反序列化时被反射调用，

    如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

    Singleton类：

    public class Singleton implements Serializable {

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

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    
    // 解决序列化反序列化破解单例模式
    private Object readResolve() {
        return SingletonHolder.INSTANCE;
    }
}

    源码解析：

    ObjectInputStream类

    public final Object readObject() throws IOException, ClassNotFoundException{
    ...
    // if nested read, passHandle contains handle of enclosing object
    int outerHandle = passHandle;
    try {
        Object obj = readObject0(false);
        // 重点查看readObject0方法
    .....
}
    
private Object readObject0(boolean unshared) throws IOException {
	...
    try {
		switch (tc) {
			...
			case TC_OBJECT:
				return checkResolve(readOrdinaryObject(unshared));
                // 重点查看readOrdinaryObject方法
			...
        }
    } finally {
        depth--;
        bin.setBlockDataMode(oldMode);
    }    
}
    
private Object readOrdinaryObject(boolean unshared) throws IOException {
	...
	// isInstantiable 返回true，
    // 执行 desc.newInstance()，通过反射创建新的单例类，
    obj = desc.isInstantiable() ? desc.newInstance() : null; 
    ...
    // 在Singleton类中添加 readResolve 方法后 
    // desc.hasReadResolveMethod() 方法执行结果为true
    if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
    	// 通过反射调用 Singleton 类中的 readResolve 方法，
        // 将返回值赋值给rep变量
        
    	// 这样多次调用ObjectInputStream类中的readObject方法，
        // 继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。
    	Object rep = desc.invokeReadResolve(obj);
     	...
    }
    return obj;
}

  • 反射方式破解单例的解决方法

    public class Singleton {

    //私有构造方法
    private Singleton() {

        // 反射破解单例模式
        if(instance != null) {
            throw new RuntimeException();
        }
    }
    
    private static volatile Singleton instance;

    // 对外提供静态方法获取该对象
    public static Singleton getInstance() {

        if(instance != null) {
            return instance;
        }

        synchronized (Singleton.class) {
            if(instance != null) {
                return instance;
            }
            instance = new Singleton();
            return instance;
        }
    }
}

    直接不干了！当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。

在这里插入图片描述

3.3 JDK源码解析-Runtime类

Runtime类就是使用的单例设计模式。

  1. Runtime类使用的是恶汉式（静态属性）方式来实现单例模式的。

    public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    ...
}

  2. 使用Runtime类中的方法

    public class RuntimeDemo {
    public static void main(String[] args) throws IOException {
        // 获取Runtime类对象
        Runtime runtime = Runtime.getRuntime();

        // 返回 Java 虚拟机中的内存总量。
        System.out.println(runtime.totalMemory());
        // 返回 Java 虚拟机试图使用的最大内存量。
        System.out.println(runtime.maxMemory());

        // 创建一个新的进程执行指定的字符串命令，返回进程对象
        Process process = runtime.exec("ipconfig");
        // 获取命令执行后的结果，通过输入流获取
        InputStream inputStream = process.getInputStream();
        byte[] arr = new byte[1024 * 1024* 100];
        int b = inputStream.read(arr);
        System.out.println(new String(arr,0,b,"gbk"));
    }
}

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值