二十三天搞懂设计模式之单例模式的七种写法

一时失言乱红尘 2022-10-04 14:55 117阅读 0赞

### 文章目录 ###

*  二十三天搞懂设计模式之单例模式的七种写法
 *   *  1. 介绍
     *  2. 使用场景
     *  3. 九种实现方法
     *   *  3.1 饿汉式 V1.0
         *  3.2 饿汉式 V2.0
         *  3.3 懒汉式 V1.0
         *  3.4 懒汉式 V2.0
         *  3.4 懒汉式测试 V3.0
         *  3.5 双端检验锁（DCL，既：\*\*double-checked locking\*\*）
         *  3.6 静态内部类
         *  3.7 枚举
     *  4. 总结

# 二十三天搞懂设计模式之单例模式的七种写法 #

## 1. 介绍 ##

单例模式（Singletion Pattern）是 Java 中最简单的设计模式之一。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。

这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。

*  单例类只能有一个实例
 *  单例类必须自己创建自己的唯一实例
 *  单例类必须给其他对象提供这一实例

## 2. 使用场景 ##

*  要求生产唯一的序列号
 *  WEB中的计数器，不用每次都去数据库里加一次，用单例缓存起来
 *  创建一个对象需要消耗的资源过多，比如I/O与数据库的连接

**优点**

*  在内存中只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
 *  避免对资源的多重占用

**缺点**

*  没有接口、不能继承
 *  只关心内部逻辑，不考虑外部如何实例化

## 3. 九种实现方法 ##

### 3.1 饿汉式 V1.0 ###

*  当该类被加载到内存时，就会实例化一个单例，**JVM** 保证其线程安全
 *  唯一缺点：不管能不能用到，类装载时就会完成实例化
 *  评价：简单实用，推荐使用

public class Mgr01 {
        
    
        private static final Mgr01 INSTANCE = new Mgr01();
    
        private Mgr01() {
        
        }
    
        public static Mgr01 getInstance() {
        
            return INSTANCE;
        }
    
        public static void main(String[] args) {
        
            Mgr01 mgr01 = Mgr01.getInstance();
            Mgr01 mgr02 = Mgr01.getInstance();
            System.out.println(mgr01 == mgr02);
        }
    }

### 3.2 饿汉式 V2.0 ###

*  饿汉式2.0版本对于饿汉式1.0版本来说，将原本的实例化放入了static代码块中
 *  评价：面试可以简单提一下，除了装逼，没啥作用

public class Mgr02 {
        
        private static final Mgr02 INSTANCE;
    
        static {
        
            INSTANCE = new Mgr02();
        }
    
        private Mgr02() {
        
        }
    
        public static Mgr02 getInstance() {
        
            return INSTANCE;
        }
    }

### 3.3 懒汉式 V1.0 ###

*  只有我需要的时候，我才会去进行实例化，达到了按需初始化的目的
 *  缺点：不支持多线程，因为没有加锁，在多线程状态下不能正常工作

public class Mgr03 {
        
        private static Mgr03 INSTANCE;
    
        private Mgr03() {
        
    
        }
    
        public static Mgr03 getInstance() {
        
            if (INSTANCE == null) {
        
                try {
        
                    Thread.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                INSTANCE = new Mgr03();
            }
            return INSTANCE;
        }
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println(Mgr03.getInstance().hashCode());
                    }
                }).start();
            }
        }
    }

### 3.4 懒汉式 V2.0 ###

*  相较于 **1.0** 版本，在 **2.0** 版本中加入了 **synchronized** 关键字保证其实例化。
 *  缺点：加锁会影响效率

public class Mgr04 {
        
        private static Mgr04 INSTANCE;
    
        private Mgr04() {
        
    
        }
    
        public static synchronized Mgr04 getInstance() {
        
            if (INSTANCE == null) {
        
                try {
        
                    Thread.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                INSTANCE = new Mgr04();
            }
            return INSTANCE;
        }
    
       
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println(Mgr04.getInstance().hashCode());
                    }
                }).start();
            }
        }
    }

### 3.4 懒汉式测试 V3.0 ###

*  这是懒汉式的一个 **测试** 的升级版本
 *  相较于 **2.0** 版本，主要对 **synchronized** 的位置进行了优化
 *  缺点：当两个线程同时进入到该方法且 **INSTANCE** 为NULL，同样会产生线程不安全的情况
    
     *  原因：当后来的线程夺取到CPU的执行权时，会再次创建一个Mgr05的实例化
     *  总结：这个测试版本没什么用，只是为了引出DCL，面试的时候让面试官觉得你是个很有思考能力的人

public class Mgr05 {
        
        private static Mgr05 INSTANCE;
        private Mgr05(){
        };
        public static Mgr05 getInstance(){
        
            // 妄想通过减少同步代码块的方式去提高效率，然后不可行
            if(INSTANCE == null){
        
                synchronized (Mgr05.class){
        
                    try {
        
                        Thread.sleep(1);
                    }catch (Exception e){
        
                        e.getStackTrace();
                    }
                    INSTANCE = new Mgr05();
                }
            }
            return INSTANCE;
        }
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println(Mgr05.getInstance().hashCode());
                    }
                }).start();
            }
        }
    }

### 3.5 双端检验锁（DCL，既：**double-checked locking**） ###

*  最重要的一个单例，面试装逼手撕必备，更含有 **volatile** 这一必考点，实乃装逼之神器
 *  为什么用双端检锁？
    
     *  主要为了解决上述懒汉式测试版本出现的无效问题
 *  将 synchronized 直接放在外面，里面加一个判断null不可以吗？
    
     *  可以是可以，但是在一般情况下，多个线程同时走到同一行代码的判断是比较少的
     *  当我们的某个线程已经创建了实例化，我们在外面加一个判断，就会筛过之后的线程，不需要进行锁的争夺
 *  为什么用 **volatile** ?
    
     *  Java 在进行编译的时候，为了使程序效率加快，会将没有相互联系的指令进行指令重排
     *  对象在创建的时候，分为三个阶段
        
        1.  给 **INSTANCE** 分配堆内存
        2.  调用 **Mgr06** 的构造函数来初始化成员变量，形成实例
        3.  将 **INSTANCE** 指针指向分配的内存空间（执行完这步 **INSTANCE** 才是非 null了）
     *  正常来讲：按照 **1-2-3** 的顺序是不会出错的，但是指令重排可能会出现 **1-3-2** 的情况，我们的对象还没有初始化成员变量，就已经分配好内存空间，造成数据的严重错误。

public class Mgr06 {
        
        private volatile static Mgr06 INSTANCE;
    
        private Mgr06() {
        
        }
        public static Mgr06 getInstance() {
        
            if (INSTANCE == null) {
        
                synchronized (Mgr06.class) {
        
                    try {
        
                        Thread.sleep(1);
                    } catch (Exception e) {
        
                        e.getStackTrace();
                    }
                    if (INSTANCE == null) {
        
                        INSTANCE = new Mgr06();
                    }
                }
            }
            return INSTANCE;
        }
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println(Mgr06.getInstance().hashCode());
                    }
                }).start();
            }
        }
    }

### 3.6 静态内部类 ###

*  **JVM** 保证单例，只加载一次
 *  加载外部类时不会加载内部类，这样可以实现懒加载，真正的实现了按需加载的目的

public class Mgr07 {
        
        private Mgr07(){
        
    
        }
        private static class Mgr07Handle{
        
            private static final Mgr07 INSTANCE = new Mgr07();
        }
    
        public static Mgr07 getInstance(){
        
            return Mgr07Handle.INSTANCE;
        }
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println(Mgr07.getInstance().hashCode());
                    }
                }).start();
            }
        }
    }

### 3.7 枚举 ###

*  面试可以简单一提，让面试官对你刮目相看
 *  方法的出处：**Effective Java** 作者 **Josh Bloch** 提倡的方式
 *  它不仅能避免多线程同步问题，还可以防止序列化和反序列化
    
     *  枚举类没有构造方法
     *  源码规定，在反射的时候，判断该类是否被ENUM修饰，如果是则直接抛出异常，反射失败

public enum Mgr08 {
        
        INSTANCE;
        public Mgr08 getInstance(){
        
            return INSTANCE;
        }
    }

## 4. 总结 ##

博主在面试小米、美团时被问到这个问题，回答方法也和本文类似，按以下流程回答，方可让面试官刮目相看

*  什么是单例？
 *  单例的进化
 *  杀手锏DCL双端检验锁
    
     *  讲清为什么两次检验的原因
     *  讲清 **volatile** 的指令重排，当然，可直接扩展至可见性，CPU缓存行，看个人发挥
 *  最后，提一下静态内部类和枚举

祝大家都能拿到好的offer，有什么问题可以加我微信或者留言

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTE1NDM5_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTE1NDM5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221004/3c887311cae049e9b22064aee42691eb.png