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

ゝ一纸荒年。 2022-03-10 12:18 281阅读 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  
![在这里插入图片描述][2019031104101383.png]  
现在我们开始调试 Dug启动 LazySimpleSingletonTest 类  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5fbGFuZw_size_16_color_FFFFFF_t_70]  
然后我们跟着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 进行了赋值，是饿汉式单例的实现

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

[2019031104101383.png]: /images/20220310/d2471e346aeb4b94b52a103c6ad23d3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5fbGFuZw_size_16_color_FFFFFF_t_70]: /images/20220310/2260b704ee8041c6b57c12c130a58ce1.png