乐趣区

Android-10-设计模式-系列-单例

jiezi

前言

因为源码剖析的代码量比拟大，大部分博客网站的内容显示页面都比拟窄，显示进去的成果都异样俊俏，所以您也能够间接查看《Thinking in Android》来浏览这边文章，心愿这篇文章能帮你梳理分明 “单例模式”。

一、概述

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() 的时候，就会创立多个实例。

是否多线程平安 否
实现难度 易
长处 第一次调用才初始化，防止内存节约
毛病 当多个线程并行调用 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;  
        }  
    }

办法阐明

既然要线程平安，那就如上所述进行 “加锁” 解决！

是否多线程平安 是
实现难度 易
长处 第一次调用才初始化，防止内存节约
毛病 必须加锁 synchronized 能力保障单例，但加锁会影响效率（加锁操作也是耗时的）

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（双重校验锁），而且还能避免反序列化导致从新创立新的对象。

退出移动版