单例模式的7种实现方式及比较

比眉伴天荒 2022-03-06 05:00 176阅读 0赞

> 单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例，即一个类只有一个对象实例。 – 百度百科

### 问题的由来 ###

多个线程要操作同一对象，需要保证对象的唯一性。

### 解决思路 ###

*  该类的构造方法为私有，防止外部实例化该类的对象
 *  该类中要有一个对象实例化过程（只有一次）
 *  该类需要提供返回实例对象的方法

### 解决方案 ###

为了更好的对下面即将介绍的几种实现方式进行比较，我们定义几个考量维度：**线程的安全线、是否懒加载、性能**。

#### 方法一：饿汉式单例模式【可用】 ####

public class BadmashSingleton {
        // 在类加载的时候即被实例化
        private static BadmashSingleton instance = new BadmashSingleton();
        private BadmashSingleton() {
        }
    
        public static BadmashSingleton getInstance() {
            return instance;
        }
    }

*  **线程安全性：** 实例在类加载的时候即被实例化，因此线程安全。
 *  **是否懒加载：** 没有延迟加载，如果长时间没用到这个实例，则会造成内存的浪费。
 *  **性能：** 性能比较好

#### 方法二：懒汉式单例模式【多线程有问题】 ####

public class IdlerSingleton {
        private static IdlerSingleton instance = null;
        private IdlerSingleton() {
        }
    	// 在使用时才进行加载
        public static IdlerSingleton getInstance() {
            if (null == instance) {
                instance = new IdlerSingleton();
            }
            return instance;
        }
    }

*  **线程安全性：** 单线程下没有问题，多线程下有可能会生成多个实例，因此线程不安全。
    
     *  问题出现在`if (null == instance)`这一步，多线程环境中可能会有多个线程同时拿到instance的值为null。
 *  **是否懒加载：** 懒加载
 *  **性能：** 性能比较好

#### 方法三：懒汉式单例模式+同步方法【性能差，不推荐使用】 ####

public class IdlerSynSingleton {
        private static IdlerSynSingleton instance = null;
        private IdlerSynSingleton() {
        }
    
        public static synchronized IdlerSynSingleton getInstance() {
            if (null == instance) {
            	instance = new IdlerSynSingleton();
            }
            return instance;
        }
    }

*  **线程安全性：** 线程安全
 *  **是否懒加载：** 懒加载
 *  **性能：** `synchronized`修饰方法，使得多线程执行退化为串行执行，性能差

#### 方法四：懒汉式单例模式+同步代码块【不可用】 ####

该方法是对上面方法的一个优化，将同步方法改为同步代码块。

public class IdlerSynSingleton {
        private static IdlerSynSingleton instance = null;
        private IdlerSynSingleton() {
        }
    
        public static IdlerSynSingleton getInstance() {
            if (null == instance) {
                synchronized (IdlerSynSingleton.class) {
                    instance = new IdlerSynSingleton();
                }
            }
            return instance;
        }
    }

*  **线程安全性：** 单线程下没有问题，多线程下有可能会生成多个实例，因此线程不安全。
    
     *  问题同样出现在`if (null == instance)`这一步
 *  **是否懒加载：** 懒加载
 *  **性能：** 性能一般

#### 方法五：DCL单例模式+Volatile【可用】 ####

为了解决方法四存在的线程不安全问题，我们引入双重锁，即Double-Check-Locking。同时引入`volatile`关键字修饰实例对象，这是为了避免因JVM指令重排序可能导致的空指针异常。因为当线程执行到第一个`if (null == instance)`时，代码可能读取到instance不为null，但此时instance引用的对象可能还没有完成初始化。

public class DCLSingleton {
        private static volatile DCLSingleton instance = null;
        private DCLSingleton() {
        }
    
        public static DCLSingleton getInstance() {
            if (null == instance) {
                synchronized (DCLSingleton.class) {
                    if (null == instance) {
                        instance = new DCLSingleton();
                    }
                }
            }
            return instance;
        }
    }

*  **线程安全性：** 线程安全性
 *  **是否懒加载：** 懒加载
 *  **性能：** 性能比较好

#### 方法六：Holder单例模式【推荐】 ####

声明类时，成员变量中不声明实例变量，而是放到静态内部类中。这种方式和懒汉式有些相似，它们都采用了类装载的机制来保证初始化实例时只有一个线程，不同的是，Holder单例模式是将实例的初始化放到了静态类中去实现，从而实现了懒加载。

public class HolderSingleton {
        private static HolderSingleton instance = null;
        private HolderSingleton() {
        }
    
        public static HolderSingleton getInstance() {
            return Holder.instance;
        }
    
        private static class Holder {
            private static HolderSingleton instance = new HolderSingleton();
        }
    }

*  **线程安全性：** 线程安全性
 *  **是否懒加载：** 懒加载
 *  **性能：** 性能好

#### 方法七：Enum单例模式【推荐】 ####

借助了enum枚举类的特性，直接解决了多线程同步问题。

public class EnumSingleton {
        private EnumSingleton() {
        }
    
        public static EnumSingleton getInstance() {
            return EnumHolder.INSTANCE.getInstance();
        }
    
        private enum EnumHolder {
            INSTANCE;
            private EnumSingleton instance = null;
    
            private EnumHolder() {
                instance = new EnumSingleton();
            }
    
            private EnumSingleton getInstance() {
                return instance;
            }
        }
    }

*  **线程安全性：** 线程安全性
 *  **是否懒加载：** 懒加载
 *  **性能：** 性能好

### 总结 ###

本文共列举了七种单例模式的实现方式，推荐使用后面两种方式。

--------------------

\------------本文结束感谢您的阅读------------