单例模式 - Singleton Patterns

本文主要是介绍单例模式 - Singleton Patterns，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

父博文地址：设计模式 - Design Patterns

一、单例模式的意义

Design Patterns 一书中对单例模式描述：

Ensure a class only has one instance, and provide a global point of access to it.
确保一个Class只有一个实例，并对外提供一个全局访问点。

单例模式是最容易理解的设计模式。道理简单，不过如何写出一个“正确”的单例模式一开始并不简单。Talk is cheap. Show me the code.

单例模式的代码有两种不同的方式，一种被叫做所谓的“饿汉式”，另一种叫“懒汉式”。

二、饿汉方式

饿汉的意思是：急切的……，即急切的创建实例。代码如下：

/*** “饿汉式”，即“急切的方式”。*/
public class Singleton {private static Singleton instance = new Singleton();private Singleton() {}public static Singleton getInstance() {return instance;}
}

优点：实现简单、线程安全，JVM保证在任何线程能访问instance之前，实例化new Singleton()已被执行完成。
缺点：如果实例化new Singleton()很耗资源，而对象在很久之后才会被用到或者本次程序运行中都用不到，则浪费了系统资源。

三、懒汉方式（懒加载）

针对“急切方式”的缺点，可以使用这种称为“懒加载”的方式来实现单例模式。

1. 第一遍代码：错误代码1

/*** 懒汉式，错误代码1* <p>* 错误原因：线程不安全。安全写法见${@link LazyInitializationCorrect}* </p>*/
public class LazyInitializationError {private static LazyInitializationError instance;private LazyInitializationError() {}public static LazyInitializationError getInstance() {if (instance == null) {instance = new LazyInitializationError();}return instance;}
}

错误发生流程：

线程Thread1执行完if (instance == null)后失去了CPU执行权。
线程Thread2再次执行了if (instance == null)并得到true，然后它也失去执行权。
Thread1恢复执行，实例化了一个对象并赋值给了instance，return给调用方。
Thread2恢复执行，它不知道instance已经不为null，所以会再次实例化一个新对象并return给调用方。

2. 第二遍代码：有性能损耗

/*** 懒汉式，性能有损耗*/
public class LazyInitializationSlowly {private static LazyInitializationSlowly instance;private LazyInitializationSlowly (){}public static synchronized LazyInitializationSlowly getInstance() {if (instance == null) {instance = new LazyInitializationSlowly();}return instance;}
}

缺点：每次调用getInstance()都需要先获取锁，造成资源损耗。

3. 第三遍代码：错误代码2

使用Double-checked locking 可以避免效率降低，请看以下代码。不过注意：下面代码其实仍有问题，具体在注释中。

/*** 懒汉式，错误代码2** <p>* 使用了“Double-checked locking”，但不幸的是，在Java环境下注意这是又一个错误的写法，错误描述见代码注释* <br>安全写法见${@link LazyInitializationCorrect}* </p>*/
public class LazyInitializationErrorNoVolatile {private static LazyInitializationErrorNoVolatile instance;private LazyInitializationErrorNoVolatile() {}/*** Double-checked locking*/public static LazyInitializationErrorNoVolatile getInstance() {// first check 第一次检查并不会尝试获取锁，避免了性能损耗if (instance == null) {synchronized (LazyInitializationErrorNoVolatile.class) {// double checkif (instance == null) {instance = new LazyInitializationErrorNoVolatile();// 一、上面这句代码在JVM中被分解为3个指令// 1. 为对象分配内存空间（例如内存地址为：10001）。// 2. 调用构造函数初始化对象。// 3. 局部变量instance 指向对象被分配的内存空间。（即10001，执行完这步后instance 非null ）// 二、问题：// 由于JVM的JIT编译器存在着称为“指令重排序”的优化行为，所以上面这行代码的指令执行顺序并非一定是“1-2-3”，// 有可能被优化为“1-3-2”，这在Java内存模型中是完全合法的。所以错误出现在：// 1. Thread1执行指令的顺序为“1-3-2”且在执行了“1-3”后丢失了CPU的执行权，此时3已执行所以instance为非null；// 2. Thread2获取执行权，当执行到first check 时，发现结果为false所以直接return instance，然而此时instance指向的对象并没有初始化完成，随即程序可能崩溃。// 三、解决问题：// JDK1.5后volatile的语义被扩展了，使用volatile关键字即可解决。// volatile的一个语义是：阻止指令重排序优化，使得上面执行的顺序必须是“1-2-3”即可。}}}return instance;}
}

4. 第四遍代码：正确写法

即上例代码的有volatile版本。

/*** 懒汉式，正确写法*/
public class LazyInitializationCorrect {private static volatile LazyInitializationCorrect instance;private LazyInitializationCorrect() {}public static LazyInitializationCorrect getInstance() {// Double-checked lockingif (instance == null) {synchronized (LazyInitializationCorrect.class) {if (instance == null) {instance = new LazyInitializationCorrect();}}}return instance;}
}

四、另一种正确的懒加载

懒加载还有一种效率更高的正确写法叫 Initialization-on-demand holder idiom，这种方式效率很高因为没有同步代码，当然它也有一定的局限性，这些在注释中详细的写了出来：

/*** 懒汉式，使用Hodler方式** <p>完全线程安全，“Initialization-on-demand holder idiom”，但有一定限制</p>*/
public class LazyInitializationCorrectWithHolder {private LazyInitializationCorrectWithHolder() {}// 1. LazyInitializationCorrectWithHolder被JVM加载时，如果Holder类没被任何代码引用到的话，是不会被加载的，所以这里满足了“懒”；private static class Holder {private static final LazyInitializationCorrectWithHolder INSTANCE = new LazyInitializationCorrectWithHolder();}public static LazyInitializationCorrectWithHolder getInstance() {// 2. 当外部代码调用 getInstance() 时，Holder才会被加载并执行；// 3. 又由于JVM保证了class的初始化是按照既定顺序的，不会多线程的，所以 INSTANCE 的初始化是线程安全的。return Holder.INSTANCE;}// 4. 使用这种风格的单例，必须满足一个条件，构造函数的过程不能发生异常导致初始化失败。（double checked方式没有这个限制）// 错误代码如下，当初始化失败后，其它线程也不能再次完成初始化了，因为会一直发生LazyInitializationCorrectWithHolder$Holder NoClassDefFoundError// private LazyInitializationCorrectWithHolder() {//     if (Thread.currentThread().getName().equals("Threadddd-0")) {//         int i = 1/0;//     }// }// public static void main(String[] args) {//     for (int i = 0; i < 3; i++) {//         final Thread thread = new Thread(new Runnable() {//             @Override//             public void run() {//                 getInstance();//             }//         });//         thread.setName("Threadddd-" + i);//         thread.start();//     }// }
}