设计模式之一单例模式
目录结构
前言
接下来的系列文章我们会谈设计模式，设计模式不仅仅存在Java开发语言中，而是遍及软件领域且至关重要，是前辈开发总结的经验，一种设计思想，一种架构；在软件开发中，唯一不变的就是需求的变化，开发人员不仅要满足当下的功能需求，还要考虑对后续可能的变化，设计的系统就应有良好的拓展性。在公司接手上一任的代码，继续开发新功能，如果设计的拓展性不好的话，后期开发会很困难，费时费力，还可能对之前的功能有影响，心里也是忐忑不安，同时也给测试人员添加负担，改动点增多，测试范围增大等等，可见设计模式的重要性。
本文讲述较为简单的单例模式，单例模式要保证系统中对象唯一，这不是获取对象方的责任，是对象提供方保证这个对象在系统中就只能存在一个。如何保证对象的唯一性，就要从创建对象的角度，创建对象可以通过构造方法，Clone对象，反序列化时创建对象，反射四种方式，那么就需要让类内部创建唯一对象，不让外部直接创建，只提供一个方法供外部获取对象。所以单例模式中第一步构造方法私有，不让外部new 对象，其次实现单例模式的类不会实现Cloneable接口，则不支持Clone对象；前2种方式都能避免，主要是反序列化和反射机制容易破坏单例。以下我们来分别讨论单例模式的几种方式和其存在的问题，以及反序列化和反射如何破坏单例，怎样去避免，如何合理设计单例模式？
创建对象四种方式：
- 1、构造方法
- 2、Clone对象
- 3、反序列化时创建对象
- 4、反射
创建单例的常见几种方式：
- 1、懒汉式
- 2、饿汉式
- 3、双检锁
- 4、静态内部类方式
- 5、双检锁变式 - CAS自旋锁
- 6、枚举
一、懒汉式
在需要使用的时候，才创建对象（延迟实例化），存在多线程安全问题。
package designpattern.singleton;
/**
* @author zdd
* 2020/1/10 5:15 下午
* Description: 懒汉式创建单例
*/
public class LazyInstantiateTest {
private static LazyInstantiateTest INSTANCE;
//1、私有构造方法,防止被其他类创建对象
private LazyInstantiateTest(){};
//2、对外提供静态公共方法获取单例对象
public static LazyInstantiateTest getInstance() {
if(INSTANCE == null) {
INSTANCE = new LazyInstantiateTest();
}
return INSTANCE;
}
}
二、饿汉式
也称预加载方式，类在加载初始化时就创建单例对象，饿汉抢食般地创建对象，因此以“饿汉”形容，不存在线程安全问题，但是会占用内存，类一被加载进来就实例化对象到堆中，可能很长时间才被使用或者未被使用，如此造成资源浪费。
package designpattern.singleton;
import java.io.Serializable;
/**
* @author zdd
* 2020/1/10 5:31 下午
* Description: 饿汉式实现单例
*/
public class HungryTest implements Serializable {
private static HungryTest INSTANCE = new HungryTest();
private HungryTest() {};
public static HungryTest getInstance() {
return INSTANCE;
}
}
三、双检锁
package designpattern.singleton;
/**
* @author zdd
* 2020/1/10 5:42 下午
* Description: 双检锁单例
*/
public class DoubleCheckTest {
//注：双检锁实例对象 volatile关键字修饰很重要，保证可见性，以及防止指令重排序
private static volatile DoubleCheckTest INSTANCE;
private DoubleCheckTest() {}
public static DoubleCheckTest getInstance() {
//1,第一次判空为了提高程序效率
if(INSTANCE ==null) {
//加锁，这里使用的监视器对象是该类的字节码对象
synchronized (DoubleCheckTest.class){
//2、第二次判空是为了解决多线程安全问题
if (INSTANCE == null) {
INSTANCE = new DoubleCheckTest();
}
}
}
return INSTANCE;
}
}
四、静态内部类
静态内部类借助的是类加载机制，内部类只有在被调用的时候才加载进来，实现延迟创建对象，是饿汉式的改进，既避免了初始化就创建对象占用内存，又能避免懒汉式的线程安全问题。
package designpattern.singleton;
import java.io.Serializable;
/**
* @author zdd
* 2020/1/10 5:55 下午
* Description: 静态内部类单例
*/
public class StaticInnerClassTest {
//内部类
private static class InstanceInnerClass {
private final static StaticInnerClassTest
INSTANCE = new StaticInnerClassTest();
}
private StaticInnerClassTest(){}
public static StaticInnerClassTest getInstance() {
return InstanceInnerClass.INSTANCE;
}
}
五、双检锁变式 - CAS自旋锁
网上有个面试题
面试官问：如何在不使用关键字synchronized、Lock锁的情况下，保证线程安全地实现单例模式？
能够线程安全创建单例，除了枚举外，有静态内部类和双检锁方式，双检锁用了关键字synchronized,静态内部类利用的类加载的机制，底层也是含有加锁操作的。要想实现不用锁，可以参考循环CAS，无阻塞轮询，利用cas自旋锁原理。
首先写一个自旋锁类
package designpattern.singleton;
import cas.SpinLockTest;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/**
* @author zdd
* 2020/1/10 6:59
* Description: CAS无阻塞自旋锁
*/
public class CasLock {
static AtomicReference<Thread> atomicReference = new AtomicReference<>();
public static void lock() {
Thread currentThread = Thread.currentThread();
for (;;) {
boolean flag =atomicReference.compareAndSet(null,currentThread);
if(flag) {
break;
}
}
}
public static void unLock() {
Thread currentThread = Thread.currentThread();
Thread momeryThread = atomicReference.get();
//比较内存中线程对象与当前对象，不相等就抛出异常，防止未获取到锁的线程调用 unlock
if(currentThread != momeryThread) {
throw new IllegalMonitorStateException();
}
//释放锁
atomicReference.compareAndSet(currentThread,null);
}
}
实现双检锁变式单例模式
package designpattern.singleton;
import cas.SpinLockTest;
/**
* @author zdd
* 2020/1/10 6:46
* Description: cas实现单例，实际是cas自旋锁，在synchronized阻塞式加锁的改进，无阻塞式加锁
*/
public class SingletonCasTest {
private static volatile SingletonCasTest INSTANCE;
private static CasLock spinLock = new CasLock();
private SingletonCasTest() {};
public static SingletonCasTest getInstance() {
if(INSTANCE == null) {
spinLock.lock();
if (INSTANCE == null) {
INSTANCE = new SingletonCasTest();
}
spinLock.unLock();
}
return new SingletonCasTest();
}
}
六、枚举
枚举类是《Effective Java》书中推荐的实现单例方式，因为其天然的可防止反序列化和反射破解单例的唯一性，保证有且仅有一个对象，
因太简洁，可读性不强。
package designpattern.singleton;
/**
* @author zdd
* 2020/1/10 6:43 下午
* Description:
*/
public enum SingletonEnum{
INSTANCE;
}
七、存在的问题
7.1 线程安全
一是需要考虑线程安全问题，这是懒汉式存在的问题，为了解决该问题，可以将getInstance() 方法加上synchronized关键字或者在方法内部加同步代码块，或者用Lock锁机制，这样会导致多线程在获取单例对象时线程安全了，但是效率会降低，同步代码块会比同步方法效率更高一些，主要是同步代码块应该尽可能的缩小代码块的包含范围（标准是恰好包括临界区部分）,粒度越小，并发度才更高。
7.2 反序列问题
二是反序列化问题，在需要将对象序列化与反序列化时，首先让该单例类实现Serializable接口（标志接口，无内容，实现类可序列化），然而存在的问题就是在反序列化时会新创建一个对象，这样就违背了单例模式的对象唯一性。
将对象先转为字节写入到输入流中（序列化过程），再从输出流中读取字节，再转换为对象 （反序列化）
代码示例如下：
package designpattern.singleton;
import java.io.*;
/**
* @author zdd
* 2020/1/10 7:23 下午
* Description: 反序列化破坏单例对象唯一性
*/
public class DeserializableProblemTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//先将对象加载到输入流中，在到输出流获取对象,以饿汉式单例为例
HungryTest hungry1 = HungryTest.getInstance();;
HungryTest hungry2 = null;
//1,将单例对象写入流中
ByteArrayOutputStream ops = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(ops);
oos.writeObject(hungry1);
//2,再从流中读出，转换为对象
ByteArrayInputStream ips= new ByteArrayInputStream(ops.toByteArray());
ObjectInputStream ois = new ObjectInputStream(ips);
hungry2 =(HungryTest) ois.readObject();
//3、判断是否为同一个对象
System.out.println(hungry1 ==hungry2);
}
}
运行结果： 证明反序列化后又新创建了对象
false
解决反序列化问题：在HungryTest类中添加如下方法
//防止反序列化破坏单例
private Object readResolve() {
return INSTANCE;
}
再执行运行结果为 true ,证明是同一个对象，未创建新对象。
为什么添加一个readResolve 方法就可以防止反序列化创建新的对象呢？
进入ObjectInputStream的 readObject() 可见，下面只列出关键代码位置，详细可自己查看源码
首先类要支持序列化，通过反射创建新对象赋值给obj
继续往下看，这里有if判断，满足3个条件，其中hasReadResolveMethod判断是否有readResolve方法，有则调用该方法，最后obj被readResolve返回对象覆盖。
那么readResolveMethod需要满足什么要求？ 满足以下3个条件即可
参考博客：单例模式的攻击之序列化与反序列化
7.3 反射
三是反射，我们知道Java中反射几乎是无所不能，你不让我创建对象，那就暴力反射创建，我们如何防止反射破解单例？
暴力反射破坏单例示例：
package designpattern.singleton;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @author zdd
* 2020/1/13 2:49 下午
* Description: 暴力反射破解单例
*/
public class ReflectBreakSingletonTest {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//1,获取单例对象
HungryTest hungry1 = HungryTest.getInstance();
//2, 获取HungryTest类字节码对象
Class<HungryTest> hungryClass= HungryTest.class;
//3,获取构造器对象
Constructor<HungryTest> hungryConstructor = hungryClass.getDeclaredConstructor();
//4,设置暴力反射为true
hungryConstructor.setAccessible(true);
//5,通过构造器对象调用默认构造器创建对象 --> 反射
HungryTest hungry2= hungryConstructor.newInstance();
//6, 判断两个对象是否相同
System.out.println(hungry1 == hungry2);
}
}
运行结果： false
证明反射可以破坏单例对象唯一，新创建对象。
如何防止反射对单例的攻击？
既然反射攻击是调用默认构造器，那么反射在调用构造器时就抛出异常不让其创建对象。依然以饿汉式为例，修改默认构造方法，如果反射调用就抛出异常！
private HungryTest() {
if(null !=INSTANCE) {
throw new RuntimeException("不支持反射调用默认构造器！");
}
};
问：以上6种单例模式都可以通过在默认构造方法中抛异常防止暴力反射吗？
答：除去枚举（其天然防止反射），其他5种分为2类，类初始化就创建对象为预加载方式，另一类为延迟加载方式；饿汉式、静态内部类为预加载方式 ，懒汉式、双检锁、双检锁变式为延迟加载方式。这里预加载可以用以上方法防止暴力反射，延迟加载不行，因为在默认构造方法中首先会对单例对象判空，延迟加载在获取单例时是没有创建对象的，这时可以通过反射创建对象，因此无法防止反射攻击，因此推荐的是枚举方式实现单例，省心省力。
参考博客：单例模式的攻击之反射攻击
总结
本文从单例模式的几种方式入手，分析每个的特点及问题，其中它们公共的特点是私有构造方法，再提供一个公开静态的方法供外部获取对象；我们在理解这几种方式原理后，能够很容易写出这些单例，分析每种方式存在的问题，以及改进的方式，其中线程安全问题，反序列化问题，反射问题应着重注意，如此我们也能较为全面了解单例模式。
