荐 「 Android 10 设计模式 」系列 -- “ 单例 “

作者：DeepCoder

一、概述

1.1 什么是单例？

这种模式涉及到一个 单一的类 ，该类负责 创建自己的对象 ，同时确保 只有单个对象被创建 。这个类 提供了一种访问其唯一的对象的方式 ，可以直接访问， 不需要实例化该类的对象 。

我们需要注意：

单例类 ：只能有一个实例（有且唯一）。

单例类 ：必须自己创建自己的唯一实例（自己创建自己）。

单例类 ：必须给所有其他对象提供这一实例（提供给别人调用自己的方法）。

1.2 举个例子

我们看个简单的 “单例设计” 的 Demo，先创建一个 Singleton（单例） 类： SingleObject.java

public class SingleObject {
 
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();    --> 1、有且仅有一个实力；2、自己创建自己的实例
 
   // 让构造函数为 private，这样该类就无法被实例化
   private SingleObject(){}
 
   // 获取唯一可用的对象
   public static SingleObject getInstance(){    --> 3、为其他对象提供自己的实例
      return instance;
   }
 
   public void showMessage(){
      System.out.println("Hello World!");
   }
}

然后我们再创建一个类 SingletonPatternDemo.java 去获取 SingleObject 的实例：

public class SingletonPatternDemo {
   public static void main(String[] args) {
 
      // 不合法的构造函数，编译时错误：构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();
 
      // 获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
 
      // 显示消息
      object.showMessage();
   }
}

我们看下执行结果：

Hello World!

二、实现方式

2.1 基本版：饿汉式

代码范例

public class Singleton {  

        private static Singleton instance = new Singleton();    // 类加载时就初始化
        private Singleton (){}  
    
        public static Singleton getInstance() {  
            return instance;  
        }  
    }

方法说明

这种方式比较常见，典型的 “饿汉式” 写法。

2.2 改进版：懒汉式 - 线程不安全

代码范例

public class Singleton {  

        private static Singleton instance;    // 类加载时不作初始化
        private Singleton (){}  
  
        public static Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
    }

方法说明

这种方式是大多数面试者的写法，也是教科书上的标配，但这段代码却存在一个致命的问题：当多个线程并行调用 getInstance() 的时候，就会创建多个实例。

2.3 改进版：懒汉式 - 线程安全

代码范例

public class Singleton {  

        private static Singleton instance;  
        private Singleton (){}  
    
        public static synchronized Singleton getInstance() {    // 加锁
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
    }

方法说明

既然要线程安全，那就如上所述进行 “加锁” 处理！

2.4 改进版：双重校验锁

代码范例

public class Singleton {  

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

方法说明

为什么需要进行 2 次判断是否为空呢？

第一次判断是为了避免不必要的同步，第二次判断是确保在此之前没有其他进程进入到 synchronized 块创建了新实例。

这段代码看起来很完美，很可惜，它还是有隐患！

主要在于 instance = new Singleton() 这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情：

✵ 1、给 instance 分配内存

✵ 2、调用 Singleton 的构造函数来初始化成员变量

✵ 3、将 instance 对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

但是在 JVM 的即时编译器中存在 指令重排序 的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，最后顺理成章地报错。

2.5 改进版：双检锁（volatile）

代码范例

public class Singleton {  

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

方法说明

有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。

使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。

也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。

但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM （Java 内存模型）是存在缺陷的，即使将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。

那么，有没有一种既有懒加载，又保证了线程安全，还简单的方法呢？

当然有， 静态内部类就是这么一种我们想要的方法 。我们完全可以把 Singleton 实例放在一个静态内部类中，这样就避免了静态实例在 Singleton 类加载的时候就创建对象，并且由于静态内部类只会被加载一次，所以这种写法也是线程安全的。

2.6 终极版：静态内部类

代码范例

public class Singleton {  

        private static class SingletonHolder {  
            private static final Singleton INSTANCE = new Singleton();  
        }  
    
        private Singleton (){}  
    
        public static final Singleton getInstance() {  
            return SingletonHolder.INSTANCE;  
        }  
}

方法说明

这是比较推荐的解法，这种写法用 JVM 本身的机制保证了线程安全的问题，同时读取实例的时候也不会进行同步，没什么性能缺陷，还不依赖 JDK 版本。

2.7 传说版：枚举

代码范例

public enum Singleton {  
        INSTANCE;  
    }

方法说明

这是从 Java 1.5 发行版本后就可以实用的单例方法，我们可以通过 Singleton.INSTANCE 来访问实例，这比调用 getInstance() 方法简单多了。

创建枚举默认就是线程安全的，所以不需要担心 double checked locking（双重校验锁） ，而且还能防止反序列化导致重新创建新的对象。

三、总结

以上就是「 Android 10 设计模式 」系列 – " 单例 "的内容了

在这我也分享一份大佬自己收录整理的Android学习PDF+架构视频+面试文档+源码笔记，还有高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料这些都是我闲暇还会反复翻阅的精品资料

总之也是在这里帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习

如果你有需要的话，可以点赞+评论 ，关注我，然后私信我获取~

点击【Android学习PDF+架构视频+面试文档+源码笔记】加入我们的圈子领取资料和我们一起吧学习交流吧！

本文地址：https://blog.csdn.net/ajsliu1233/article/details/107364366