常用设计模式——深入理解单例模式

最新推荐文章于 2023-07-08 14:02:34 发布

zhan_lang

最新推荐文章于 2023-07-08 14:02:34 发布

阅读量222

点赞数

分类专栏：设计模式文章标签：设计模式单例模式

本文链接：https://blog.csdn.net/zhan_lang/article/details/88387108

版权

设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

单例模式：
前言：一听说单例模式是不是觉得很简单什么饿汉模式懒汉模式分分钟信手拈来其实它远远不止这些那么今天我们就来详细的介绍一下单例模式让你再和别人谈及单例模式的时候分分钟秒杀别人。

定义（什么叫单例）：单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。

场景：在 J2EE 标准中，ServletContext、ServletContextConfig 等；在 Spring 框架应用中 ApplicationContext；数据库的连接池也都是单例形式

一：饿汉式单例：

什么叫饿汉式单例呢？就是在类加载的时候就立即初始化，并且创建单例对象（我以前总是不能区分懒汉和饿汉的区别在这里呢就认为饿汉比较饥饿在类加载的时候就创建对象了这样是不是更容易记忆一些）

public class HungrySingleton {

    //类加载的时候就创建单例对象 
    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    /**
     * 获取单例对象
     * @return
     */
    public  static HungrySingleton getInstance(){
        return hungrySingleton;
    }

}

饿汉式单例是不是很简单？那么它有什么优缺点呢？我们来总结一下：

优点：没有加任何的锁、执行效率比较高绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题
缺点：浪费内存类加载的时候就初始化，不管你用还是不用，我都占着空间（如果存在很多类似对象的时候比较明显）

二：懒汉式单例

什么是懒汉式单例呢？在外部需要使用的时候才进行实例化

/**
 * 懒汉式单例
 */
public class LazySimpleSingleton {

    private static LazySimpleSingleton lazySimpleSingleton ;

    /**
     * 在外部需要使用的时候才进行实例化
     * @return
     */
    public static LazySimpleSingleton getInstance(){
    	//断点
        if (lazySimpleSingleton == null){
            lazySimpleSingleton = new LazySimpleSingleton();
        }
        return lazySimpleSingleton;
    }

}

这里你是不是还是觉得非常简单，这里是很简单，但是你有没有考虑过线程安全的问题？如果两个线程同时进入了 if (lazySimpleSingleton == null) 判断那么就有可能参数两个不同的对象，那我们现在来验证一下，
第一步：创建一个线程并打印单例地址

/**
 * 创建一个线程并打印单例地址
 */
public class ExectorThread implements Runnable{
    
    @Override
    public void run() {
   		//断点
        LazySimpleSingleton1 singleton = LazySimpleSingleton1.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + singleton);
    }
    
}

第二步：启用两个线程模拟创建对象的过程

/**
 * 启用两个线程 模拟创建对象的过程
 */
public class LazySimpleSingletonTest {

    public static void main(String[] args) {
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
        //断点
        System.out.println("End");
    }
}

调试准备：在这里我们把所有的断点右键选择Thread
在这里插入图片描述
现在我们开始调试 Dug启动 LazySimpleSingletonTest 类

然后我们跟着dug走（将两个线程同时执行到 if (lazySimpleSingleton == null) 判断当中去）这里不难发现执行结果当我线程一创建对象后然后执行线程二发现打印了两个一样的结果这里是被覆盖了那么我们怎么打游了两个不一样的结果呢？还是将两个线程进入到if判断当中去然后让一个线程执行完接着再执行另外一个线程这样就创建了两个不同的对象了这里就是我们所说的线程安全的问题。

在这里你的第一反应是不是在 getInstance 方法添加 synchronized关键字呢？这样直接加锁很有可能把我们整个类都给锁了那么还有没有另外的加锁方式呢？不要着急当然有，那就是双重校验

 /**
     * Double check
     * @return
     */
    public  static LazySimpleSingleton getInstance(){
        if (lazySimpleSingleton == null){
            synchronized (LazySimpleSingleton.class){
                if (lazySimpleSingleton == null){
                    lazySimpleSingleton = new LazySimpleSingleton();
                }
            }

        }
        return lazySimpleSingleton;
    }

三：静态内部类单例

对于上面两种单例模式都有各自的缺点那么有没有更优的一种解决办法呢？

/**
 * 这种形式兼顾饿汉式的内存浪费，也兼顾synchronized性能问题
 */
public class LazyClassSingleton {


    public static LazyClassSingleton getInstance(){
        return Lazy.Lazy;
    }

    private static class Lazy{
        private static final LazyClassSingleton Lazy = new LazyClassSingleton();
    }

}

但是这种方式也有缺点就是在调用的时候调用者不采用getInstance获取而是用反射获取

//很无聊的情况下，进行破坏
            Class<?> clazz = LazyClassSingleton.class;

            //通过反射拿到私有的构造方法
            Constructor c = clazz.getDeclaredConstructor(null);
            c.setAccessible(true);

            //暴力初始化
            Object o1 = c.newInstance();
            //调用了两次构造方法，相当于new了两次
            //犯了原则性问题，
            Object o2 = c.newInstance();
            System.out.println(o1 == o2);

那么这种情况又怎么来避免呢？这样的话我们就可以修改一下构造方法

 //如果没使用的话，内部类是不加载的
    private LazyClassSingleton(){
        if(Lazy.Lazy!= null){
            throw new RuntimeException("不允许创建多个实例");
        }
    }

四：枚举单例（枚举单例是《EffectiveJava》书中推荐的一种单例实现写法）

@Data
public enum EnumSingleton {
    
    INSTANCE;
    
    private Object data;
    
    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}

枚举式单例在静态代码块中就给 INSTANCE 进行了赋值，是饿汉式单例的实现

五：序列化破坏单例
当我们将一个单例对象创建好，有时候需要将对象序列化然后写入到磁盘，下次使用时
再从磁盘中读取到对象，反序列化转化为内存对象。反序列化后的对象会重新分配内存，
即重新创建。那如果序列化的目标的对象为单例对象，就违背了单例模式的初衷，相当
于破坏了单例

zhan_lang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用设计模式——深入理解单例模式

单例模式：前言：一听说单例模式是不是觉得很简单什么饿汉模式懒汉模式分分钟信手拈来其实它远远不止这些那么今天我们就来详细的介绍一下单例模式让你再和别人谈及单例模式的时候分分钟秒杀别人。定义（什么叫单例）：单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。场景：在 J2EE 标准中，Servle...
复制链接

扫一扫