单例模式
下面所有代码都可在 gitee: git@gitee.com:xiaodongcoder/design-patterns.git 上找到
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
1. 单例模式的结构
单例模式的主要有以下角色：
- 单例类。只能创建一个实例的类
- 访问类。使用单例类
2. 单例模式的实现
单例模式的实现分为两种：
- 饿汉式：类加载就会导致该单实例对象被创建
- 懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建
2.1. 饿汉式-方式1（静态变量方式）
代码位置：com.dsl.singleton.demo01.Singleton
package com.dsl.singleton.demo01;
/**
* @author DSL
* @description 饿汉式，通过静态变量创建类的对象
* @date 2022/11/11 13:01
* @since 1.0
*/
public class Singleton {
/**
* 私有构造方法
*/
private Singleton() {}
/**
* 在成员位置创建该类的对象
*/
private static final Singleton instance = new Singleton();
/**
* 对外提供静态方法获取该对象
* @return 该对象的实例
*/
public static Singleton getInstance() {
return instance;
}
}
该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。
2.2. 饿汉式-方式2（静态代码块方式）
代码位置：com.dsl.singleton.demo02.Singleton
package com.dsl.singleton.demo02;
/**
* @author DSL
* @description 饿汉式，通过静态代码块创建类的对象
* @date 2022/11/11 13:06
* @since 1.0
*/
public class Singleton {
/**
* 私有构造方法
*/
private Singleton(){}
/**
* 在成员位置创建该类的对象
*/
private static Singleton instance;
/**
* 对外提供静态方法获取该对象
*/
static {
instance = new Singleton();
}
public static Singleton getInstance(){
return instance;
}
}
该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。
2.3. 懒汉式-方式1（线程不安全）
com.dsl.singleton.demo03.Singleton
package com.dsl.singleton.demo03;
/**
* @author DSL
* @description 懒汉式，线程不安全
* @date 2022/11/11 13:53
* @since 1.0
*/
public class Singleton {
/**
* 私有构造方法
*/
private Singleton() {
}
/**
* 在成员位置创建该类的对象
*/
private static Singleton instance;
/**
* 对外提供静态方法获取该对象
* @return 单例对象
*/
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
从上面代码我们可以看出该方式在成员位置声明 Singleton 类型的静态变量，并没有进行对象的赋值操作，当调用 getInstance() 方法获取 Singleton 类的对象的时候才创建 Singleton 类的对象，这样就实现了懒加载的效果。但是，由于创建该方法的所有语句不是原子性的所以在多线程环境，会出现线程安全问题。
2.4 懒汉式-方式2（线程安全）
代码位置：com.dsl.singleton.demo04.Singleton
在第三种的基础上，由于 getInstance() 方法不是原子性的，所以我们可以在该方法上加上 synchronized 关键字
package com.dsl.singleton.demo04;
/**
* @author DSL
* @description 懒汉式-方式2（线程安全）
* @date 2022/11/11 13:55
* @since 1.0
*/
public class Singleton {
/**
* 私有构造方法
*/
private Singleton() {
}
/**
* 在成员位置创建该类的对象
*/
private static Singleton instance;
/**
* 对外提供静态方法获取该对象
* @return 单例对象
*/
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在 getInstance() 方法上添加了 synchronized 关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化 instance 的时候才会出现线程安全问题，一旦初始化完成就不存在了。
2.5 懒汉式-方式3（双重检查锁）推荐
对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机，只需要在初始化的时侯加锁就行了。由此也产生了一种新的实现模式：双重检查锁模式。
package com.dsl.singleton.demo05;
/**
* @author DSL
* @description 懒汉式-方式3（双重检查锁）
* @date 2022/11/11 13:59
* @since 1.0
*/
public class Singleton {
/**
* 私有构造方法
*/
private Singleton() {
}
/**
* 在成员位置创建该类的对象
*/
private static Singleton instance;
/**
* 对外提供静态方法获取该对象
* @return 单例对象
*/
public static Singleton getInstance() {
// 1. 第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
if (instance == null) {
synchronized (Singleton.class){
// 2. 抢到锁之后再次判断是否为null
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是 JVM 在实例化对象的时候会进行优化和指令重排序操作，既instance = new Singleton(); 这个语句不是原子性的。
要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。
代码位置：com.dsl.singleton.demo05.Singleton
package com.dsl.singleton.demo05;
/**
* @author DSL
* @description 懒汉式-方式3（双重检查锁）
* @date 2022/11/11 13:59
* @since 1.0
*/
public class Singleton {
/**
* 私有构造方法
*/
private Singleton() {
}
/**
* 在成员位置创建该类的对象
*/
private static volatile Singleton instance;
/**
* 对外提供静态方法获取该对象
* @return 单例对象
*/
public static Singleton getInstance() {
// 1. 第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
if (instance == null) {
synchronized (Singleton.class){
// 2. 抢到锁之后再次判断是否为null
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。
2.6 懒汉式-方式4（静态内部类方式）
静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。
com.dsl.singleton.demo06.Singleton
package com.dsl.singleton.demo06;
import java.io.Serializable;
/**
* @author DSL
* @description 懒汉式（静态内部类方式）
* @date 2022/11/11 14:04
* @since 1.0
*/
public class Singleton implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 私有构造方法
*/
private Singleton() {
if (SingletonHolder.INSTANCE != null) {
throw new RuntimeException();
}
}
/**
* 创建内部类
*/
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
/**
* 对外提供静态方法获取该对象
*
* @return 单例对象
*/
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用 getInstance，虚拟机加载 SingletonHolder
并初始化 INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。
静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。
2.7 枚举方式（饿汉式）
枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。
代码位置：com/dsl/singleton/demo07/Singleton.java:9
package com.dsl.singleton.demo07;
/**
* @author DSL
* @description 饿汉式：使用枚举方式创建单例对象
* @date 2022/11/11 14:07
* @since 1.0
*/
public enum Singleton {
/**
* 单例对象
*/
INSTANCE;
}
3. 存在的问题以及解决方案
使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。这里使用的案例是：2.6 静态内部类的代码
3.1. 使用反射机制破坏单例模式
代码位置：com.dsl.singleton.demo06.Test
package com.dsl.singleton.demo06;
import java.lang.reflect.Constructor;
/**
* @author DSL
* @description 通过反射机制破坏单例模式
* @date 2022/11/11 16:43
* @since 1.0
*/
public class Test {
public static void main(String[] args) throws Exception {
// 1. 获取 Singleton 字节码对象
Class<Singleton> clazz = Singleton.class;
// 2. 获取Singleton类的私有无参构造方法对象
Constructor<Singleton> constructor = clazz.getDeclaredConstructor();
// 3. 取消访问检查
constructor.setAccessible(true);
// 4. 创建两个 Singleton 对象
Singleton singleton = constructor.newInstance();
Singleton singleton1 = constructor.newInstance();
// 5. 比较对象地址：结果为 false
System.out.println(singleton1 == singleton);
}
}
通过输出的结果，可以看出使用反射机制已经破坏了单例模式
3.2. 使用序列化方式破坏单例模式
package com.dsl.singleton.demo06;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* @author DSL
* @description 通过序列化反序列化破坏单例模式
* @date 2022/11/11 16:48
* @since 1.0
*/
public class Test02 {
public static void main(String[] args) throws Exception {
// 1. 向文件中写对象
// writeObject2File();
// 2. 从文件中读取对象
Singleton singleton = readObjectFromFile();
Singleton singleton1 = readObjectFromFile();
// 3. 比较两个对象的地址是否相同，结果是 false
System.out.println(singleton1 == singleton);
}
/**
* 将对象序列化到文件中
* @throws Exception 这里不考虑异常
*/
private static void writeObject2File() throws Exception {
Singleton instance = Singleton.getInstance();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\Users\Lenovo\Desktop\a.txt"));
oos.writeObject(instance);
}
/**
* 从文件中反序列化对象到内存中
* @return 文件中的对象
* @throws Exception 这里不考虑异常
*/
private static Singleton readObjectFromFile() throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\Users\Lenovo\Desktop\a.txt"));
return (Singleton) ois.readObject();
}
}
通过输出的结果，可以看出使用序列化和反序列化方式已经破坏了单例模式。
3.3. 解决反射机制破坏单例模式的问题
当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。
/**
* 私有构造方法
*/
private Singleton02() {
if (SingletonHolder.INSTANCE != null) {
throw new RuntimeException();
}
}
3.4. 解决序列化反序列化破坏单例模式的问题
在Singleton类中添加readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。
/**
* 下面是为了解决序列化反序列化破解单例模式
*/
private Object readResolve() {
return SingletonHolder.INSTANCE;
}
完整代码：
package com.dsl.singleton.demo08;
import java.io.Serializable;
/**
* @author DSL
* @description 解决反射机制和序列化反序列化方式破坏单例模式的静态内部类方式（懒汉式）
* @date 2022/11/11 22:24
* @since 1.0
*/
public class Singleton02 implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 私有构造方法
*/
private Singleton02() {
if (SingletonHolder.INSTANCE != null) {
throw new RuntimeException();
}
}
/**
* 创建内部类
*/
private static class SingletonHolder {
private static final Singleton02 INSTANCE = new Singleton02();
}
/**
* 对外提供静态方法获取该对象
*
* @return 单例对象
*/
public static Singleton02 getInstance() {
return Singleton02.SingletonHolder.INSTANCE;
}
/**
* 下面是为了解决序列化反序列化破解单例模式
*/
private Object readResolve() {
return SingletonHolder.INSTANCE;
}
}
4. 单例模式最佳实践
- 双重检查锁方式（懒汉式）
com.dsl.singleton.demo08.Singleton01
package com.dsl.singleton.demo08;
import com.dsl.singleton.demo05.Singleton;
import java.io.Serializable;
/**
* @author DSL
* @description 解决反射机制和序列化反序列化方式破坏单例模式的双重检查锁方式（懒汉式）
* @date 2022/11/11 22:14
* @since 1.0
*/
public class Singleton01 implements Serializable {
/**
* 私有构造方法，并且在通过反射调用该方法时，如果 instance 不为空，既要再次建立新对象时，抛出异常
*/
private Singleton01() {
if (instance != null) {
throw new RuntimeException();
}
}
/**
* 在成员位置创建该类的对象，使用 volatile 修饰
*/
private static volatile Singleton01 instance;
/**
* 对外提供静态方法获取该对象
* @return 单例对象
*/
public static Singleton01 getInstance() {
// 1. 第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
if (instance == null) {
synchronized (Singleton.class){
// 2. 抢到锁之后再次判断是否为null
if (instance == null) {
instance = new Singleton01();
}
}
}
return instance;
}
/**
* 下面是为了解决序列化反序列化破解单例模式
* @return
*/
private Object readResolve() {
return Singleton01.getInstance();
}
}
- 静态内部类方式（懒汉式）
com.dsl.singleton.demo08.Singleton02
package com.dsl.singleton.demo08;
import java.io.Serializable;
/**
* @author DSL
* @description 解决反射机制和序列化反序列化方式破坏单例模式的静态内部类方式（懒汉式）
* @date 2022/11/11 22:24
* @since 1.0
*/
public class Singleton02 implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 私有构造方法
*/
private Singleton02() {
if (SingletonHolder.INSTANCE != null) {
throw new RuntimeException();
}
}
/**
* 创建内部类
*/
private static class SingletonHolder {
private static final Singleton02 INSTANCE = new Singleton02();
}
/**
* 对外提供静态方法获取该对象
*
* @return 单例对象
*/
public static Singleton02 getInstance() {
return Singleton02.SingletonHolder.INSTANCE;
}
/**
* 下面是为了解决序列化反序列化破解单例模式
*/
private Object readResolve() {
return SingletonHolder.INSTANCE;
}
}
- 枚举类（饿汉式）
com.dsl.singleton.demo08.Singleton03
package com.dsl.singleton.demo08;
/**
* @author DSL
* @description 饿汉式：使用枚举方式创建单例对象
* @date 2022/11/11 14:07
* @since 1.0
*/
public enum Singleton03 {
/**
* 单例对象
*/
INSTANCE;
}
