浅谈设计模式-单例模式

已于 2022-04-20 11:52:43 修改
阅读量407 收藏
点赞数 1
分类专栏： 浅谈设计模式 文章标签： 单例模式 饿汉式 懒汉式 反序列化 设计模式
于 2022-04-13 23:43:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langfeiyes/article/details/124160087
版权

书接上回，本篇讲一下创建型模式-单例设计模式

单例设计模式

定义：一个类有且仅有一个唯一的实例，并提供一个可对外访问的方法。

注意：本篇研究的是单个进程，分布式/微服务场景不适用。

Singleton：私有化构造器，避免外部创建实例，类内部创建唯一的实例，并提供getInstance方法让外部访问这个实例。

案例分析

java中，单例模式的编写方式有：饿汉式，懒汉式，双重检查式，静态内部类式，枚举式等，每一种都有自己的优缺点，这一一介绍一下。

饿汉式  

/**
 * 饿汉式
 */
public class Singleton implements Serializable {
    //唯一的实例
    private static Singleton instance = new Singleton();
    //私有的构造器，避免外部构建实例
    private Singleton() {
    }
    //提供唯一对外部访问方法
    public static Singleton getInstance() {
        return instance;
    }
    //普通实例方法
    public void show(){
        System.out.println(this);
    }
}

解析

饿汉式，人如其名，极度饥饿唯一想法就是吃。代码中体现就是尽可能快创建出实例，所以在类加载进入虚拟机时就马上构建出唯一的实例。

单例测试

注意：所有测试方法都需要单独运行，一起调用会线程安全测试方法会有误差

普通访问测试：结果为true 

//普通访问实例
private static void instanceAccess(){
    Singleton instance1 = Singleton.getInstance();
    Singleton instance2 = Singleton.getInstance();
    System.out.println("第一次获取实例与第二次获取实例==值比较：" + (instance1 == instance2));
}

反射构建测试：结果为false 

//反射构建实例访问
private static void reflectAccess(){
    Class<?> aClass = null;
    try {
        aClass = Class.forName("com.langfeiyes.singleton.Singleton");
        Constructor<?> constructor = aClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Object o = constructor.newInstance();
        Singleton instance  = (Singleton) o;

        System.out.println("反射构建实例与正常获取实例==值比较：" + (instance == Singleton.getInstance()));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

反系列化构建测试：结果为false 

//系列化构建后实例
private static void serializableAccess(){
    Singleton instance = Singleton.getInstance();
    try {
        @Cleanup //lombok的注解，资源释放
        ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("singleton.txt"));
        output.writeObject(instance);
        @Cleanup
        ObjectInputStream input = new ObjectInputStream(new FileInputStream("singleton.txt"));
        Object o = input.readObject();

        Singleton instance2 = (Singleton) o;
        System.out.println("反系列化建实例与正常获取实例==值比较：" + (instance2 == Singleton.getInstance()));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

线程安全测试：结果为线程安全 

//线程安全测试
private static void threadAccess(){
    ExecutorService service = Executors.newFixedThreadPool(100);
    //线程栅栏，当所有线程同时准备就绪之后，开闸。开闸那一瞬间可以认为是多线程并发
    final CyclicBarrier barrier = new CyclicBarrier(100);
    for (int i = 0; i < 100; i++) {
        final int aa = i;
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    barrier.await();
                    System.out.println(Singleton.getInstance());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    service.shutdown();
}

结论

饿汉式单例模式：

1>线程安全的，

2>正常单例访问是可以保证实例唯一，

3>反射构建，反系列化构建，无法保证单例。

4>无延时加载功能

懒汉式

/**
 * 懒汉式
 */
public class Singleton implements Serializable {
    //唯一的实例，此时实例为null，当第一次反问时再构建
    private static Singleton instance;

    //私有的构造器，避免外部构建实例
    private Singleton() {
    }

    //提供唯一对外部访问方法
    public static Singleton getInstance() {
       if(instance == null){
           instance = new Singleton();
       }
       return instance;
    }
    //普通实例方法
    public void show(){
        System.out.println(this);
    }
}

解析

懒汉式，人如其名，很懒，外部不获取实例，不创建。第一次获取实例时，创建对象，并缓存，后续通过判空返回缓存的对象

单例测试

跟饿汉式测试代码一样

普通访问测试：结果为true

反射构建测试：结果为false

反系列化构建测试：结果为false

线程安全测试：结果为线程不安全

为放大显示效果，修改一下测试单例：getInstance方法代码。得出会构建多个实例，线程不安全。

//提供唯一对外部访问方法
public static Singleton getInstance() {
    if(instance == null){
        try {
            Thread.sleep(100);  //模拟并发时间差
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        instance = new Singleton();
    }
    return instance;
}

双重检查式

懒汉式单例写法线程不安全，该如何保证线程安全呢？ 答案：加锁

方案1：单例方法加锁 

//提供唯一对外部访问方法
public static synchronized Singleton getInstance() {
    if(instance == null){
        instance = new Singleton();
    }
    return instance;
}

不建议，这种加锁方式太笨重，锁区范围太大，锁住了整个方法。

方案2：双重检查 

//注意加上volatile 关键字，线程可见
private static volatile Singleton instance;
//提供唯一对外部访问方法
public static  Singleton getInstance() {
    //①位置
    if(instance == null){ 
        //②位置
        synchronized (Singleton.class){
            //③位置
            if(instance == null){
                //④位置
                instance = new Singleton();
            }
        }
    }
    return instance;
}

问：为什么双重检查方式可以做到线程安全？

答：很简单，当多线程并发访问getInstance方法是，①②位置都可以多线程聚集，但同时进入③位置线程有且仅有一个，也就是说，唯一实例只允许唯一一个线程创建，一但创建成功之后，不在允许再执行new Singleton() 逻辑了。

静态内部类方式

/**
 * 静态内部类
 */
public class Singleton implements Serializable {
    //私有的构造器，避免外部构建实例
    private Singleton() {
    }
    //私有静态内部类
    private static class SingletonInner{
        //唯一的实例
        private static  Singleton INSTANCE = new Singleton();
    }
    //提供唯一对外部访问方法
    public static Singleton getInstance() {
        return SingletonInner.INSTANCE;
    }
    //普通实例方法
    public void show(){
        System.out.println(this);
    }
}

解析

静态内部类，也是人如其名，在内部定义一个静态内部类，内部类私有化，持有唯一实例，这操作好处，外部类加载时并不需要立马加载内部类，只有外部调用getInstance()时，第一次使用内部类，虚拟机才会加载内部类。

单例测试

跟饿汉式测试代码一样

普通访问测试：结果为true

反射构建测试：结果为false

反系列化构建测试：结果为false

线程安全测试：结果为线程安全（原因：JVM加载字节码时候是对字节码对象加锁的）

枚举类

/**
 * 枚举方式
 */
public enum  Singleton implements Serializable {
    INSTANCE;
    //提供唯一对外部访问方法
    public static Singleton getInstance() {
        return INSTANCE;
    }
    //普通实例方法
    public void show(){
        System.out.println(this);
    }
}

解析

枚类，枚举类有个特点，当枚举类定义完成之后，实例个数就固定了。如果约定实例个数为1，那就是标准单例模式了。

单例测试

跟饿汉式测试代码一样

普通访问测试：结果为true

反射构建测试：报错java.lang.NoSuchMethodException: com.langfeiyes.singleton.Singleton.<init>()

反系列化构建测试：结果为true

序列化的时候Java对将枚举对象的name属性输出到结果中，反序列化的时候则是通过java.lang.Enum的valueOf方法来根据名字查找枚举对象。另外编译器是不允许任何对这种序列化机制的定制的，那么系列化与反系列化操作对枚举类型实例就失效了。

线程安全测试：结果为线程安全

枚举类似饿汉式一样，线程安全的。

单例小结

对上面5中单例模式做个小结

饿汉式单例模式：

1>线程安全的，

2>正常单例访问是可以保证实例唯一，

3>反射构建，反系列化构建，无法保证单例。

4>无延时加载功能

懒汉式单例模式

1>线程不安全的，

2>正常单例访问是可以保证实例唯一

3>反射构建，反系列化构建，无法保证单例。

4>有延时加载功能

双重检查单例模式

1>线程安全的，

2>正常单例访问是可以保证实例唯一

3>反射构建，反系列化构建，无法保证单例。

4>有延时加载功能

静态内部类单例模式

1>线程安全的，

2>正常单例访问是可以保证实例唯一

3>反射构建，反系列化构建，无法保证单例。

4>有延时加载功能

枚举类单例模式

1>线程安全的，

2>正常单例访问是可以保证实例唯一

3>反射构建报错，反系列化构建可以保证单例。

4>无延时加载功能

总结：

模式线程是否安全反射能破坏单例么反系列化能破坏单例么有无延时加载
饿汉式是能能无
懒汉式否能能有
双重检查是能能有
静态内部类是能能有
枚举类是不能不能无

从最终的结果上面，枚举式最佳的选项。

反射与反序列化

从上面的总结表上看，处理枚举类的方式能防得住反射与反序列化的单例破坏，此时我们不经想能不能通过某种编码手段破解反射与反系列化造成的多例情况出现呢？答案是yes的，

这里我们先分析反射与反序列化造成多例的原因：

反射

//反射构建实例访问
private static void reflectAccess(){
    Class<?> aClass = null;
    try {
        aClass = Class.forName("com.langfeiyes.singleton.Singleton");
        Constructor<?> constructor = aClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Object o = constructor.newInstance();
        Singleton instance  = (Singleton) o;

        System.out.println("反射构建实例与正常获取实例==值比较：" + (instance == Singleton.getInstance()));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

反射之所以能破坏单例，原因是通过反射获取单例类中的构造器对象，并通过其对象构建实例，即使将构造方法设置为私有，一样可以被调用。

知道原因之后，解决方案就简单了：在私有的构造方法中设置不为null判断。

以懒汉式为例子

/**
 * 懒汉式
 */
public class Singleton implements Serializable {
    .....
    //私有的构造器，避免外部构建实例
    private Singleton() {
        //当已经创建唯一实例了，不允许在继续创建
        //此处可以破解 反射构建多例的问题
        if (instance !=null) {
            throw new RuntimeException("实例已经被创建，可以调用getInstance方法获得");
        }else{
            instance = this;
        }
    }

    .....
}

反序列化

反系列化之所以能构建多例，原因藏在input.readObject();方法中

//系列化构建后实例
private static void serializableAccess(){
    Singleton instance = Singleton.getInstance();
    try {
        @Cleanup //lombok的注解，资源释放
        ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("singleton.txt"));
        output.writeObject(instance);
        @Cleanup
        ObjectInputStream input = new ObjectInputStream(new FileInputStream("singleton.txt"));
        Object o = input.readObject();

        Singleton instance2 = (Singleton) o;
        System.out.println("反系列化建实例与正常获取实例==值比较：" + (instance2 == Singleton.getInstance()));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

点开readObject方法，查看源码

public final Object readObject(){
    ....
    Object obj = readObject0(false);
    ....

}

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

private Object readOrdinaryObject(boolean unshared) throws IOException{
    ....
    ObjectStreamClass desc = readClassDesc(false);
    obj = desc.isInstantiable() ? desc.newInstance() : null;
    ....
}

一路跟踪到最后核心代码

obj = desc.isInstantiable() ? desc.newInstance() : null;

当文件中读取的对象描述信息存在构造器器对象，不管是公共还是私有的，desc.isInstantiable()方法都是true， 那么它马上就通过构造器对象构建出新的对象，那么单例效果就被破坏了，这就是反序列化能破坏单例的原因。

那怎么办？重写对象的反系列化钩子方法readResolve

在反序列化过程中，java允许序列化的对象定制3个构造方法，分别为writeObject，readObject，readResolve，代码如下：一个User类

@Setter
@Getter
class User implements Serializable {
    public User(){
    }
    //系列化时调用，output.writeObject(user);，讲对象写入文件
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
    }
    //反系列化时调用，input.readObject();，返回从文件读出的对象，如果重写了readResolve，则返回readResolve的对象
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
    }
    //自定义反系列化对象
    private Object readResolve() {
        return this;
    }
}

这里重点讲readResolve方法，接着之前的readObject，继续往下看，有个非常重要的判断： desc.hasReadResolveMethod()

public final Object readObject(){
    ....
    Object obj = readObject0(false);
    ....

}

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

private Object readOrdinaryObject(boolean unshared) throws IOException{
    ....
    ObjectStreamClass desc = readClassDesc(false);
    obj = desc.isInstantiable() ? desc.newInstance() : null;
    ....
     if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
         Object rep = desc.invokeReadResolve(obj);
         if (rep != obj) {
            handles.setObject(passHandle, obj = rep);
         }

    }

    return obj;

}

Object invokeReadResolve(Object obj){
    ...
    return readResolveMethod.invoke(obj, (Object[]) null);
    ...
}

 上面代码中desc.hasReadResolveMethod() 用来检查序列化的类是否定制了readResolve，如果定制类这个类，那么会执行这个方法，将返回的对象rep跟之前通过desc.newInstance()对象进行对比，判断是否是同一个对象， 如果不是，直接将对象rep返回。

居于此，如果在单例类中定制readResolve，并将唯一单例实例返回，那么反序列化造成多例的局面就会破解啦。

饿汉式最终版本

/**
 * 懒汉式
 */
public class Singleton implements Serializable {
    //唯一的实例，此时实例为null，当第一次反问时再构建
    private static volatile Singleton instance;

    //私有的构造器，避免外部构建实例
    private Singleton() {
        //当已经创建唯一实例了，不允许在继续创建
        //此处可以破解 反射构建多例的问题
        if (instance !=null) {
            throw new RuntimeException("实例已经被创建，可以调用getInstance方法获得");
        }else{
            instance = this;
        }
    }

    //提供唯一对外部访问方法
    public static Singleton getInstance() {
        if(instance == null){
            synchronized (Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    //反系列化时，会调用这个方法，只需要重写该方法即可
    //此处可以破解 反系列化多例的问题
	private Object readResolve() {
        return getInstance();
    }

    //普通实例方法
    public void show(){
        System.out.println(this);
    }
}

克隆隐患

前面饿汉式的最终版本，其实已经算差不多了，如果你追求到极致，其实还有一个安全隐患：克隆隐患。

单例版

Singleton 实现克隆Clonseable接口， 并重写clone的方法。

/**
 * 懒汉式
 */
public class Singleton implements Serializable, Cloneable {
    //唯一的实例，此时实例为null，当第一次反问时再构建
    private static volatile Singleton instance;

    //私有的构造器，避免外部构建实例
    private Singleton() {
        //当已经创建唯一实例了，不允许在继续创建
        //此处可以破解 反射构建多例的问题
        if (instance !=null) {
            throw new RuntimeException("实例已经被创建，可以调用getInstance方法获得");
        }else{
            instance = this;
        }
    }

    //提供唯一对外部访问方法
    public static Singleton getInstance() {
        if(instance == null){
            synchronized (Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    //反系列化时，会调用这个方法，只需要重写该方法即可
    //此处可以破解 反系列化多例的问题
	private Object readResolve() {
        return getInstance();
    }

    //普通实例方法
    public void show(){
        System.out.println(this);
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

测试

public class App {
    public static void main(String[] args) throws CloneNotSupportedException {

        //克隆前
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
        System.out.println("------------------------");

        //克隆后
        Singleton clone = (Singleton) singleton.clone();
        System.out.println(clone);
    }
}

结果


com.langfeiyes.pattern.singleton.Singleton@51081592
------------------------
com.langfeiyes.pattern.singleton.Singleton@7f9a81e8

从结果上看， 很明显已经成多例了。查看源码，你就会发现克隆最终调用的Object.clone方法

@HotSpotIntrinsicCandidate
protected native Object clone() throws CloneNotSupportedException;

这个方法有点黑科技，直接在内存中开辟空间，所以能克隆出除了内置地址不一样的其他都一样的实例来。那怎么改进呢？非常简单，重写克隆方法直接返回this即可。

改进

修改Singleton 类的clone方法

@Override
public Object clone() throws CloneNotSupportedException {
	return this;
}

是不是很惊讶，哈哈！

适用场景

1>想保证任何情况下有且仅有一个实例

优缺点

优点：
在内存中只有一个实例，减少内存开销
可以避免对资源多重占用
设置全局访问点， 严格控制访问

缺点：
没有接口，扩展困难

开发案例

单例模式在很多地方都可以使用，比如工具类，比如spring 的单例bean， 比如项目中资源文件操作类等。

这里还是以JDK为例子-Runtime

Runtime jdk自带用于获取系统环境相关信息的工具类，设计为单例模式，采用的是饿汉式。

public class Runtime {
    private static final Runtime currentRuntime = new Runtime();
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    private Runtime() {}
    ....
}

总结

单例模式追求的是同一个JVM(同一个进程)有且仅有一个实例。当用常用的构建方式有：饿汉式 懒汉式 双重检查 静态内部类 枚举类 5种，大家可以根据需求自个选择。

浪飞yes
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浪飞yes

我对钱没兴趣~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值