设计模式— —单例模式

于 2021-03-11 13:43:36 发布
阅读量81 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41261251/article/details/114662652
版权

本文主要介绍单例模式。

文章目录

一、介绍

单例模式（Singleton Pattern）是属于创建型模式，它提供了一种创建对象的最佳方式。

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

注意：

  • 1、单例类只能有一个实例。
  • 2、单例类必须自己创建自己的唯一实例。
  • 3、单例类必须给外部提供接口使用单例类实例。

二、单例模式的实现

单例模式的实现分为饿汉式和懒汉式：

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

2.1 饿汉式

2.1.1 静态变量
/**
 * 饿汉式：静态变量
 */
public class Singleton {
    // 1. 构造方法私有化
    private Singleton(){}
    
    // 2. 静态变量
    private static Singleton instance = new Singleton();
    
    // 3. 提供接口供外部使用实例对象
    public static Singleton getInstance(){
        return instance;
    }
}
2.1.2 静态代码块
/**
 * 饿汉式：静态代码块
 */
public class Singleton {
    // 1.构造方法私有化
    private Singleton(){}

    // 2. 静态变量
    private static Singleton instance ;

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

    // 4. 提供接口供外部使用实例对象
    public static Singleton getInstance(){
        return instance;
    }
}
2.1.3 枚举方式

枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次。枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

/**
 * 饿汉式：枚举
 */
public enum Singleton {
    INSTANCE;
}
2.1.4 饿汉式的说明

是否 Lazy 初始化：否

是否多线程安全：是

实现难度：易

描述：这种方式比较常用，但容易产生垃圾对象。

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance() 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

2.2 懒汉式

2.2.1 线程不安全到线程安全
/**
 * 懒汉式：线程不安全
 */
public class Singleton {
    // 1. 构造方法私有化
    private Singleton(){}
    // 2. 声明静态变量
    private static Singleton instance;
    // 3. 对外提供外部静态方法调用
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

如果线程一通过instance==null的判断后，交出CPU的控制权，线程二仍然能通过instance==null的判断并创建对象，之后CPU交回给线程一时，线程一还会创建对象，此时就会导致该类不止一个对象被创建。因此该方法是线程不安全的。

我们可以在静态方法上增加关键字synchronized来保证是线程安全的。

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

这种方式是线程安全的，但由于加锁开销大，因此不常采用这种方式。

2.2.2 双重检查锁方式(DCL)

我们调整加锁的时机，不必让每个线程必须持有锁才能调用getInstance()方法，所以有了双重检查锁方式（Double-Check Locking）。

/**
 * 懒汉式：双重检查方式
 */
public class Singleton {
    // 1. 构造方法私有化
    private Singleton(){}

    // 2. 声明静态变量
    private static volatile Singleton instance;

    // 3. 对外提供静态方法调用
    public static Singleton getInstance(){
        if (instance == null){
            synchronized (Singleton.class){
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

由于JVM在实例化对象的时候会进行优化和指令重排序操作，所以在多线程的情况下，会出现空指针问题。为了解决空指针问题，只需要在静态变量上使用volatile关键字，volatile关键字可以保证可见性和有序性。

关于volatile关键字使用的说明：

  • volatile在这里并不保证可见性，可见性是由synchronized来保证的。

  • volatile在这里是禁止了指令重排序操作。指令重排序主要体现在instance = new Singleton()这条语句上，这条语句并不是原子操作，分为三个步骤：

    1. 在堆中分配对象内存；
    2. 对象初始化：填充对象必要信息+具体数据初始化+末位填充；
    3. 将对象引用指向堆内地址；

    正常执行顺序是1->2->3，其中第2步和第3步有可能发生指令重排序，即先将对象引用指向堆内地址，然后再进行对象初始化，则此时的执行顺序是1->3->2。

    如果A线程拿到锁进行对象创建，如果发生了指令重排序，先执行第1步和第3步，然后时间片到，交出CPU控制权，此时引用instance已经不为null了。如果现有B线程在第一个if进行判断，此时instance不为null，则直接返回instance，但是这个对象还没初始化，不能正常使用。

    所以volatile修饰变量避免指令重排序，保证1-2-3按顺序来，这样即使在首个拿锁者未释放锁前，有线程切入，当它在第一个if处得到instance非空时，此时instance的初始化也一定已经完成了。

2.2.3 静态内部类
/**
 * 懒汉式：静态内部类
 */
public class Singleton {
    // 1. 构造方法私有化
    private Singleton(){}

    // 2. 静态内部类，包含单例类对象
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }

    // 3. 提供静态方法供外部调用
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

静态内部类单例模式中实例由内部类创建，由于JVM在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性/方法被调用时才会被加载，并初始化其静态属性。静态属性由于被static修饰，保证只被实例化一次，并且严格保证实例化顺序。

三、存在的问题

本节主要使用静态内部类单例模式来演示两种破坏单例模式的方法以及解决方法。

3.1 序列化反序列破坏单例模式

我们可以将单例类对象写入文件中，然后从该文件中多次读取数据（对象），这时读取的对象是不同的。

public class Main {
    public static void main(String[] args) throws Exception {
        writeObjectToFile();
        readObjectFromFile();
        readObjectFromFile();
    }

    /**
     * 反序列化
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void readObjectFromFile() throws IOException, ClassNotFoundException {
        // 1. 创建输入流
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("singleton/file/obj.txt"));
        // 2. 读取数据（对象）
        Singleton instance = (Singleton) objectInputStream.readObject();
        System.out.println(instance);
        // 3. 关闭资源
        objectInputStream.close();
    }

    /**
     * 序列化
     * @throws IOException
     */
    public static void writeObjectToFile() throws IOException {
        // 1. 获取单例对象
        Singleton instance = Singleton.getInstance();
        // 2. 创建输出流
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("singleton/file/obj.txt"));
        // 3. 写出对象
        objectOutputStream.writeObject(instance);
        // 4. 关闭资源
        objectOutputStream.close();
    }
}

结果：

com.lee.lazy_loading.demo3.Singleton@737996a0
com.lee.lazy_loading.demo3.Singleton@61dc03ce

可见两次获取的对象内存地址不同，说明两个对象不同，单例模式被破坏。

解决方法：

在单例类中增加方法readResolve()，该方法在反序列化时被反射调用。在反序列时，如果定义了这个方法，就返回这个方法的值，如果没有，则返回新new出来的对象。

public Object readResolve(){
    return SingletonHolder.INSTANCE;
}

Main.main()重新运行后结果：

com.lee.lazy_loading.demo3.Singleton@617c74e5
com.lee.lazy_loading.demo3.Singleton@617c74e5

原理分析：

public final Object readObject() throws IOException, ClassNotFoundException {
    // 省略...
    try {
        Object obj = readObject0(false);
    }finally{
        // 省略...
    }
}

private Object readObject0(boolean unshared) throws IOException {
    try {
        switch (tc) {
            case TC_OBJECT:
                return checkResolve(readOrdinaryObject(unshared));
        }
    }finally{
        // 省略...
    }
}

private Object readOrdinaryObject(boolean unshared) throws IOException {
    // 通过反射创建新的单例类
    obj = desc.isInstantiable() ? desc.newInstance() : null;
    // 在Singleton类中添加readResolve()方法后，desc.hasReadResolveMethod()方法执行结果为true
    if (obj != null && handles.lookupException(passHandle) == null &&
        desc.hasReadResolveMethod())
    {
        // 通过反射调用Singleton类中的readResolve()方法，将返回值赋值给rep变量
        // 这样多次调用ObjectInputStream类中的readResolve()方法，就会多次调用我们定义的readResolve()方法，所以返回的是同一个对象
        Object rep = desc.invokeReadResolve(obj);
    }
}

3.2 反射破坏单例模式

public static void main(String[] args) throws Exception {
    // 1. 获取Singleton类的class对象
    Class<Singleton> clazz = Singleton.class;
    // 2. 获取无参构造函数
    Constructor<Singleton> constructor = clazz.getDeclaredConstructor();
    // 3. 取消访问检查
    constructor.setAccessible(true);
    // 4. 构造实例
    Singleton instance1 = constructor.newInstance();
    Singleton instance2 = constructor.newInstance();
    // 5. 查看实例是否相同
    System.out.println(instance1 == instance2);
}

结果：

false

通过反射创建的实例是不同的，所以单例模式被破坏了。

解决方法：

在Singleton类中增加字段表示构造方法是否被调用。

// 静态变量标志是否调用私有构造方法
private static Boolean flag = false;
// 1. 构造方法私有化
private Singleton(){
    if (flag){
        // flag为true，表示构造方法已被调用，再次调用时抛出异常
        throw new RuntimeException("不能创建多个对象");
    }
    // 调用构造方法后，修改标志
    flag = true;
}

结果：当利用反射创建多个对象时，抛出错误：

在这里插入图片描述

可是，这仍然没有问题吗？我们仍然可以通过反射改变flag的值。

public static void main(String[] args) throws Exception {
    // 1. 获取Singleton类的class对象
    Class<Singleton> clazz = Singleton.class;
    // 2. 获取无参构造函数
    Constructor<Singleton> constructor = clazz.getDeclaredConstructor();
    // 3. 取消访问检查
    constructor.setAccessible(true);
    // 4. 构造实例
    Singleton instance1 = constructor.newInstance();
    // 5. 通过反射修改flag的值
    Field flag = clazz.getDeclaredField("flag");
    flag.setAccessible(true);
    flag.set(null,false);
    // 6. 再次通过反射构造实例
    Singleton instance2 = constructor.newInstance();
    // 7. 查看两次构造的实例是否相同
    System.out.println(instance1 );
    System.out.println(instance2 );
}

结果如下，仍然创建了两个单例对象，单例模式仍然被破坏：

com.lee.lazy_loading.demo3.Singleton@39ba5a14
com.lee.lazy_loading.demo3.Singleton@511baa65

对于非静态内部类实现，即使在构造方法中加入判断，我们也可以简单通过两次反射创建两个对象：

// 1. 构造方法私有化
private Singleton(){
    if(instance != null){
        throw new RuntimeException("不能创建多个对象");
    }
}

// 省略...
// 4. 构造实例
Singleton instance1 = constructor.newInstance();
// 6. 再次通过反射构造实例
Singleton instance2 = constructor.newInstance();
// 7. 查看两次构造的实例是否相同
System.out.println(instance1);
System.out.println(instance2);

com.lee.lazy_loading.demo2.Singleton@7a79be86
com.lee.lazy_loading.demo2.Singleton@34ce8af7

四、通过反射破坏枚举单例模式

通过以上的分析，那么我们能不能安全的应用单例模式呢？答案是可以的。我们使用枚举方式来创建单例模式，这是安全的。

/**
 * 饿汉式：枚举
 */
public enum Singleton {
    INSTANCE;
}

类Singleton的构造方法是什么？

通过jad.exe工具反编译字节码Singleton.class文件：

jad.exe下载地址：http://www.javadecompilers.com/jad

首先将jad.exe复制到Singleton.class文件夹下：

在这里插入图片描述

然后再该文件夹下打开cmd，输入以下命令：

jad.exe -sjava Singleton.class

在这里插入图片描述

此时在同目录下产生了反编译后的文件Singleton.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:   Singleton.java

package com.lee.non_lazy_loading.demo3;


public final class Singleton extends Enum
{

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

    public static Singleton valueOf(String name)
    {
        return (Singleton)Enum.valueOf(com/lee/non_lazy_loading/demo3/Singleton, name);
    }

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

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

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

通过上述步骤，主要是找到特殊类Singleton的构造方法，方便我们通过反射创建对象。

此时我们再通过反射破坏单例模式，代码如下：

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    Class<Singleton> clazz = Singleton.class;
    Constructor<Singleton> constructor = clazz.getDeclaredConstructor(String.class, int.class);
    constructor.setAccessible(true);

    Singleton instance1 = constructor.newInstance();
    Singleton instance2 = constructor.newInstance();

    System.out.println(instance1);
    System.out.println(instance2);
}

结果报错：

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.base/java.lang.reflect.Constructor.newInstance(Constructor.java:484)
	at com.lee.non_lazy_loading.demo3.Main.main(Main.java:12)

提示不能通过反射创建枚举对象，则表示不能通过反射破坏枚举方式实现的单例模式。

五、源码分析

在JDK中，Runtime使用了饿汉式静态变量单例模式：

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

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

六、参考资料

[1] 黑马程序员设计模式视频教程：https://www.bilibili.com/video/BV1Np4y1z7BU?p=22

[2] 狂神说B站视频：https://www.bilibili.com/video/BV1B7411L7tE?p=33

[3] 详解volatile：https://blog.csdn.net/Lin_coffee/article/details/79890361

[4] jad.exe下载地址：http://www.javadecompilers.com/jad

水木子_
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值