深入理解单例模式

逃离我推掉我的手 2021-09-21 17:34 436阅读 0赞

**目录**

【1】方法一：饿汉单例

【2】方法二：懒汉单例

【3】方法三：懒汉单例加强（同步方法）

【4】方法四：懒汉单例加强（DCL）

【5】方法五：DCL加强

【6】方法六：懒汉单例加强（静态内部类）

【6】方法七：枚举单例（最完美写法）

总结

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

> 单例模式有八种写法，不是说设计模式是代表了最佳的实践吗，这一下冒出八种写法，何谈最佳？
> 
> 每一种单例的写法基本上都可以破坏其单例的属性，这就带来了安全隐患，所以每一种写法都是在之前的基础上进行加强，但是比消此涨，这会增加空间复杂度或者时间复杂度，没有最优的用法，只有最合适的用法。

这八种里面有些方法是重复的，只是写法稍变一下，重复的就不讲解了，每种方法通过多线程并发进行测试，通过构造方法执行的次数查看创建对象的数量

### 【1】方法一：饿汉单例 ###

> 饿汉单例，顾名思义，饿汉就是比饿，比较饥渴，比较冲动，一上来就进入主题，创建对象。
> 
>  *  在类加载时就创建了单例对象
>  *  只创建一个实例，绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题，JVM保证线程安全
>  *  优点：没有加任何锁，执行效率高，线程安全
>  *  缺点：不管你是否用到，类装载的时候就完成实例化，浪费内存空间（空间换时间）

public class Hungry {
        // 私有构造器
        private Hungry(){
            System.out.println(Thread.currentThread().getName());
        }
        // 指向自己实例的私有静态引用
        private static final Hungry hungry = new Hungry();
        // 以自己实例为返回值的静态的公有方法
        public static Hungry getInstance(){
            return hungry;
        }
    }
    
    // 多线程并发测试
    @Test
    public void TestMain1(){
        for (int i = 0;i < 10;i++){
            new Thread(() -> {
                Hungry.getInstance();
            }).start();
        }
    }

![image-20210205155802668][]

### 【2】方法二：懒汉单例 ###

> 懒汉模式，就是比较懒，做事比较拖拉，在调用实例方法的时候才去实例化对象，一开始我就不给你 new 对象，你来找我，我再给你创建一个对象
> 
>  *  在调用实例方法的时候才去实例化对象
>  *  在`getInstance`方法中线程不安全，会创建了多个实例
>  *  优点：一直没人用的话，就不会创建实例，节约内存空间
>  *  缺点：浪费判断时间，降低效率（时间换空间），线程不安全

public class LazyMan {
        // 私有构造器
        private LazyMan(){
            System.out.println(Thread.currentThread().getName());
        }
        // 指向自己实例的私有静态引用
        private static LazyMan lazyMan = null;
        // 以自己实例为返回值的静态的公有方法
        public static LazyMan getInstance(){
            if(lazyMan == null){
                lazyMan = new LazyMan();
            }
            return lazyMan;
        }
    }
    
    // 多线程并发测试
    @Test
    public void TestMain2(){
        for (int i = 0;i < 10;i++){
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }

![image-20210205165553057][]

### 【3】方法三：懒汉单例加强（同步方法） ###

> 方法二存在线程不安全的隐患，我们可以通过加锁来进行加强，方法声明上加上 **synchronized**，同步方法
> 
>  *  和方法二一样，在调用实例方法的时候才去实例化对象
>  *  在方法声明上加锁，保证线程安全
>  *  优点：一直没人用的话，就不会创建实例，节约内存空间，且线程安全
>  *  缺点：每次创建实例都要判断锁，浪费判断时间，降低效率（时间换空间）

public class LazyManSyn {
        // 私有构造器
        private LazyManSyn(){}
        // 私有静态引用创建对象
        private static LazyManSyn lazyManSyn = null;
        // 同步方法创建实例对象
        public static synchronized LazyManSyn getInstance(){
            if (lazyManSyn == null){
                lazyManSyn = new LazyManSyn();
            }
            return lazyManSyn;
        }
    }
    
    // 多线程并发测试
    @Test
    public void TestMain3(){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(LazyManSyn.getInstance().hashCode());
            }).start();
        }
    }

![image-20210206103944913][]

### 【4】方法四：懒汉单例加强（DCL） ###

> 方法三虽然线程安全，但每次创建实例都需要判断锁，效率低，我们可以通过双重锁来进行加强，让已经有实例对象的时候不进行锁判断，这种方式称之为DCL懒汉式
> 
>  *  和方法二一样，在调用实例方法的时候才去实例化对象
>  *  通过双重锁来防止多实例（双重判断和锁）
>  *  第一个 if 判断：提高执行效率，如果对象不为空，就直接不执行下面的程序
>  *  第二个 if 判断：在第一个 if 判断和 synchronized 锁之间，可以进来多个线程，如果没有第二个 if 判断，一个线程拿到锁 new 对象后释放锁，第二个线程又能够拿到锁 new 对象，通过第二个 if 则可以避免创建多个对象。
>  *  synchronized 锁：通过同步代码块
>  *  优点：减少了锁的判断，相对于方法三提升了效率，使用双重锁，**暂且认为线程安全**（后面再说）
>  *  缺点：其实这个方法还是存在线程不安全的隐患，在`lazyManDCL = new LazyManDCL();`创建对象的时候，不是一个原子性操作，会出现指令重排的可能，因此也可能创建多个实例

public class LazyManDCL {
        // 私有构造器
        private LazyManDCL(){}
        // 指向自己实例的私有静态引用
        private static LazyManDCL lazyManDCL = null;
        // 双重检查锁模式
        public static LazyManDCL getInstance(){
            if(lazyManDCL == null){
                synchronized (LazyManDCL.class){
                    if(lazyManDCL == null){
                        lazyManDCL = new LazyManDCL();
                    }
                }
            }
            return lazyManDCL;
        }
    }
    
    // 多线程并发测试
    @Test
    public void TestMain3(){
        for (int i = 0;i < 10;i++){
            new Thread(() -> {
                System.out.println(LazyManDCL.getInstance().hashCode());
            }).start();
        }
    }

![image-20210206103944913][]

### 【5】方法五：DCL加强 ###

> 在DCL单例模式中，虽然能够通过双重锁保证一定的线程安全性，但是在 new 对象的时候，非原子性操作造成指令重排，执行 `new LazyManDCL();` 的过程如下：
> 
> 1.  分配内存空间
> 2.  执行构造方法
> 3.  把这个对象指向这个空间
> 
> 执行代码时，为了提高性能，编译器和处理器往往会对指令进行重排序，上面的执行顺序可能是 1—>2—>3，也可能是 1—>3—>2，当执行顺序为 1—>3—>2 时，就会出现如下问题：
> 
>  *  A线程执行 1—>3 ，分配了内存空间，把这个对象指向这个空间
>  *  此时B线程进来，由于A线程指向了这个空间，造成第一个 if 判断为 false，从而直接 return 对象，由于没有初始化对象，就会报错
> 
> **因此我们要防止指令重排的现象发生，即：使用 `volatile` 关键字**，代码如下，就是在方法四的基础上加了一个 `volatile` 关键字
> 
>  *  优点：线程安全
>  *  缺点：多重判断，浪费时间，降低效率

public class LazyManDCL {
        // 私有构造器
        private LazyManDCL(){}
        // 指向自己实例的私有静态引用，使用volatile防止指令重排
        private static volatile LazyManDCL lazyManDCL = null;
        // 双重检查锁模式
        public static LazyManDCL getInstance(){
            if(lazyManDCL == null){
                synchronized (LazyManDCL.class){
                    if(lazyManDCL == null){
                        lazyManDCL = new LazyManDCL();
                    }
                }
            }
            return lazyManDCL;
        }
    }
    
    // 多线程并发测试
    @Test
    public void TestMain4(){
        for (int i = 0;i < 10;i++){
            new Thread(() -> {
                System.out.println(LazyManDCL.getInstance().hashCode());
            }).start();
        }
    }

![image-20210206115800861][]

### 【6】方法六：懒汉单例加强（静态内部类） ###

> 通过静态内部类来创建实例，静态内部类单例模式的核心原理为对于一个类，JVM在仅用一个类加载器加载它时，静态变量的赋值在全局只会执行一次！，
> 
>  *  优点1：外部类加载时，不会立即加载内部类，因此不占内存
>  *  优点2：不像DCL那样需要进行多重判断，提升了效率
>  *  优点3：第一次调用`getInstance()`方法时，虚拟机才加载`SingleOne`类，**既能保证线程安全，又能保证实例的唯一性，同时也延迟了单例的实例化**

public class SingleOne {
        // 私有构造方法
        private SingleOne(){}
        // 通过静态内部类创建实例
        private static class InnerClass{
            private static final SingleOne SINGLE_ONE = new SingleOne();
        }
        // 通过内部类返回对象实例
        public static SingleOne getInstance(){
            return InnerClass.SINGLE_ONE;
        }
    }
    
    // 多线程并发测试
    @Test
    public void TestMain5(){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(SingleOne.getInstance().hashCode());
            }).start();
        }
    }

![image-20210206185449387][]

### 【6】方法七：枚举单例（最完美写法） ###

> 上面的方法都是在忽略反射的情况下，我们都知道，反射可以破坏类，能够无视私有构造器，因此，上面的单例都可以使用反射进行破坏，为了解决反射破坏，我们可以使用枚举单例。
> 
>  *  枚举的特性本身就是单例，在任何情况下都是一个单例
>  *  直接通过`EnumSingle.INVALID`进行调用
>  *  让JVM来帮我们保证线程安全和单一实例问题

public enum EnumSingle {
        INVALID;
        public void doSomething(){}
    }
    
    // 多线程并发测试
    @Test
    public void TestMain6(){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(EnumSingle.INVALID.hashCode());
            }).start();
        }
    }

![image-20210206204120457][]

### 总结 ###

单例模式写法有很多种，稍微改动一下可能又是一种，不过最完美的还是方法七的枚举单例，但是用的最多的还是第一种，因为简单，易于理解，更适合开发者。其实我们没有必要拘泥于完美，最合适的才是最好的，用什么方式解决实际问题更合适就用什么方式，不要追求那些不必要的完美。就像两个人在一起，可能他（她）足够完美，你很喜欢，然而却因为种种原因不是那么合适，喜欢是乍见之欢，久处仍怦然，合适是你来我往，听得懂和聊得来，你是用心动的方法还是用自己能够信手拈来的方法呢？当然，即喜欢又合适是最好的，无论多难，你也总会遇到即喜欢有合适的，毕竟地球是圆的，只是时间早晚的问题！

[image-20210205155802668]: /images/20210920/ffe1c525077041308e01b31829b6fc11.png
[image-20210205165553057]: /images/20210920/94fd47b90b0d4d359a1d5bff8d2a920c.png
[image-20210206103944913]: /images/20210920/b2d9d1955b3c4788865d3dadd2237b04.png
[image-20210206115800861]: /images/20210920/545fafb5816c4ca1897591f8714ca49f.png
[image-20210206185449387]: /images/20210920/e2e62cefcb654efbb45864ed8b12b48a.png
[image-20210206204120457]: /images/20210920/f30c049de3bb45cc86dea7384fcc184f.png