聊透常见设计模式之单例模式
设计模式定义：
设计模式（Design pattern）是可复用面向对象软件的基础，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
设计模式分类
总体来说设计模式分为三大类
-
创建型模式（5种）
工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
-
结构型模式（7种）
适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
-
行为型模式（11种）
策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
单例模式
定义
保证一个类仅有一个实例，并提供一个该实例的全局访问点。——《设计模式》
为什么需要？
系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
单例模式种类
1.懒汉式V1
public class Singleton { private static Singleton instance; private Singleton (){} // 构造器私有 public static Singleton getInstance() { if (instance == null) { // 1 instance = new Singleton(); // 2 } return instance; } }
这种方式不可用 因为线程不安全
原因是在上面1处的代码如果在多线程下，一个线程进入了 if (singleton == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
2.懒汉式V2(线程安全)
public class Singleton { private static Singleton singleton; private Singleton() {} public static synchronized Singleton getInstance() { if (singleton == null) { singleton = new Singleton(); } return singleton; } }
这种方式线程安全，getInstance() 方法进行了线程同步，但是这种方式不推荐使用
缺点：
效率太低了，每个线程在想获得类的实例时候，执行 getInstance() 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低要改进。
3.双重校验锁
public class Singleton { private static volatile Singleton singleton; // 1 private Singleton() {} //私有构造函数 //静态工厂方法 public static Singleton getInstance() { if (singleton == null) { //双重检测机制 synchronized (Singleton.class) { //同步锁 if (singleton == null) { //双重检测机制 singleton = new Singleton(); } } } return singleton; } }
双重校验锁线程安全推荐使用。
疑问：
1.这种方式为什么要检查两次？检查一次行不行？
检查一次不行
第一次判断singleton == null作用是，如果单例对象已经创建，就直接返回对象，不需要进入同步锁，提高效率（我感觉这一次检查不是必须，但是推荐）
第二次判断singleton == null，假如没有这个判断，多个线程同时通过第一次singleton == null之后，只有一个线程进入临界区，其他线程排队，没有第二次检查的话，会创建多个实例，第二次是必须检查
2：在代码1处使用了关键字volatile，为什么需要？
因为 JVM 指令重排序，也就是并不限制处理器的指令顺序，说白了就是在不影响结果的情况下，顺序可能会被打乱。
在执行sInstance = new Singleton();这条命令语句时，JMM并不是一下就执行完毕的，即不是原子性，实质上这句命令分为三大部分：
- 为对象分配内存
- 执行构造方法语句，初始化实例对象
- 把sInstance的引用指向分配的内存空间
在JMM中这三个步骤中的2和3不一定是顺序执行的，如果线程A执行的顺序为1、3、2，在第2步执行完毕的时候，恰好线程B执行第一次判空语句，则会直接返回sInstance，那么此时获取到的sInstance仅仅只是不为null，实质上没有初始化，这样的对象肯定是有问题的！
而volatile关键字的存在意义就是保证了执行命令不会被重排序，也就避免了这种异常情况的发生，所以这种获取单例的方法才是真正的安全可靠！
4.饿汉式
public class Singleton { private static Singleton instance = new Singleton(); private Singleton (){} public static Singleton getInstance() { return instance; } }
5.饿汉式其他变种1 静态常量
public class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton (){} public static Singleton getInstance() { return INSTANCE; } }
6.饿汉式其他变种2 静态代码块
public class Singleton { private static Singleton instance; static { instance = new Singleton(); } private Singleton (){} public static Singleton getInstance() { return instance; } }
上面几种本质一样
优点：无线程安全问题
缺点：不能延迟加载，如果这个对象没有使用到，浪费内存
7.静态内部类
public class Singleton { private Singleton() {} private static class SingletonInstance { private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance() { return SingletonInstance.INSTANCE; } }
这种方式 避免了线程不安全，延迟加载，效率高
8.枚举
public enum EnumSingleton { INSTANCE; private Object object; EnumSingleton() { object = new Object(); } public Object getInstance() { return object; } }
优点：线程安全，能防止序列化破坏（后面说）
思考：饿汉式/静态内部类/枚举是通用什么方式保证线程安全？
以上的静态内部类、饿汉等模式均是通过定义静态的成员变量，以保证单例对象可以在类初始化的过程中被实例化。
这其实是利用了ClassLoader的线程安全机制。ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字。
所以， 除非被重写，这个方法默认在整个装载过程中都是线程安全的。所以在类加载过程中对象的创建也是线程安全的。
扩展讨论：
那么这些方式都是和synchronized有关系的，有没有哪种方式可以完全不使用synchronized的吗？
9.CAS（AtomicReference）实现单例模式
public class Singleton { private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>(); private Singleton() {} public static Singleton getInstance() { for (;;) { Singleton singleton = INSTANCE.get(); if (null != singleton) { return singleton; } singleton = new Singleton(); if (INSTANCE.compareAndSet(null, singleton)) { return singleton; } } } }
优点：
用CAS的好处在于不需要使用传统的锁机制来保证线程安全，CAS是一种基于忙等待的算法，依赖底层硬件的实现，相对于锁它没有线程切换和阻塞的额外消耗，可以支持较大的并行度。（CAS具体可以在JUC那块分享）
缺点：
CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中)，会对CPU造成较大的执行开销。
另外，代码中，如果N个线程同时执行到 singleton = new Singleton();的时候，会有大量对象被创建，可能导致内存溢出。
10.ThreadLocal实现单例模式
public class Singleton { private static final ThreadLocal<Singleton> singleton = new ThreadLocal<Singleton>() { @Override protected Singleton initialValue() { return new Singleton(); } }; public static Singleton getInstance() { return singleton.get(); } private Singleton() {} }
这种方式仅了解，不推荐使用，因为它其实失去了单例的意义
ThreadLocal 和 同步模式创建的单例区别：
ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。对于多线程资源共享的问题，同步机制(synchronized)采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。这种是
同步机制仅提供一份变量，让不同的线程排队访问，而ThreadLocal为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
破坏单例模式的方式和解决办法
1.反射破坏单例
可以通过setAccessible(true)来绕过 private 限制，从而调用到类的私有构造函数创建对象。
Singleton1 singleton1 = Singleton1.getInstance();
Constructor<Singleton1> cons = Singleton1.class.getDeclaredConstructor();
cons.setAccessible(true);
Singleton1 singleton2 = cons.newInstance(); // 注意 需要通过 Constructor newInstance
System.out.println(singleton1);
System.out.println(singleton2); 结果
com.pandacase.single.Singleton1@71bc1ae4 com.pandacase.single.Singleton1@6ed3ef1
解决办法？
思路：解决的办法可以是在私有构造器中，判断是否已经存在单例对象了，如果存在，则抛出异常
例如：
public class Singleton { private static int count = 0; private static volatile Singleton singleton; // 1 //私有构造函数 private Singleton() { synchronized (Singleton.class) { if (count > 0){ throw new RuntimeException("反射破坏单例对象....."); } count++; } } //静态工厂方法 public static Singleton getInstance() { if (singleton == null) { //双重检测机制 synchronized (Singleton.class) { //同步锁 if (singleton == null) { //双重检测机制 singleton = new Singleton(); } } } return singleton; } }
2.序列化破坏单例（前提是单例类实现了Serializable接口）
一是可以将一个单例的实例对象写到磁盘，实现数据的持久化；二是实现对象数据的远程传输。 当单例对象有必要实现 Serializable 接口时，即使将其构造函数设为私有，在它反序列化时依然会通过特殊的途径再创建类的一个新的实例，相当于调用了该类的构造函数有效地获得了一个新实例！
解决办法？
/* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */ public Object readResolve() { return instance; }
3.对象克隆破坏单例
clone()是 Object 的方法，每一个对象都是 Object 的子类，都有clone()方法。clone()方法并不是调用构造函数来创建对象，而是直接拷贝内存区域。因此当我们的单例对象实现了 Cloneable 接口时，尽管其构造函数是私有的，仍可以通过克隆来创建一个新对象，单例模式也相应失效了。
解决办法？
解决思想是，重写clone()方法，调clone()时直接返回已经实例的对象
public class Singleton implements Cloneable{ private static int count = 0; private static volatile Singleton singleton; // 1 //私有构造函数 private Singleton() { synchronized (Singleton.class) { if (count > 0){ throw new RuntimeException("反射破坏单例对象....."); } count++; } } //静态工厂方法 public static Singleton getInstance() { if (singleton == null) { //双重检测机制 synchronized (Singleton.class) { //同步锁 if (singleton == null) { //双重检测机制 singleton = new Singleton(); } } } return singleton; } // 重写 clone 方法 @Override protected Object clone() throws CloneNotSupportedException { return singleton; } }
单例模式在JDK中的应用
java.lang.Runtime#getRuntime()
应用场景
- 需要频繁的进行创建和销毁的对象；
- 创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
- 工具类对象；
- 频繁访问数据库或文件的对象。
