【设计模式】单例模式详解

单例模式：

• 定义：确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。为了防止出现重复的创建。
  单例模式是JAVA中最简单的设计模式之一。属于创建型设计模式，它提供了一种创建对象的最佳方式。
  这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有一个对象被创建。这个类提供了访问唯一对象的方法，可以直接访问，不需要new。

饿汉式：程序起始就初始化对象。

public class HungrySingle {
    // 私有空参构造方法，让初始化无法轻易被别人调用 (反射可以进行调用)
    private HungrySingle() {}

    // 在类中创建该类对象
    private static final HungrySingle single = new  HungrySingle();

    // 提供公共的访问方式，提供外接进行访问
    public static HungrySingle getInstance() {return single;}
}

• 优点：

1. 线程安全：由于实例在类加载时就创建，所以不存在多线程环境下的线程安全问题。
2. 简单易用：实现简单，不需要考虑多线程同步等复杂性。

• 缺点：

1. 浪费资源：在程序启动时即创建实例，如果该实例在后续程序运行中很少被使用，就会造成资源浪费。
2. 灵活性受限：无法实现延迟加载，不适合在实例创建过程中需要执行复杂操作的情况。
3. 可能造成加载缓慢：如果实例初始化较为耗时，会导致程序启动较慢。

懒汉式：被外部类调用才创建实例

public class LazySingle {
    // 声明私有构造方法
    private LazySingle(){};

    // 单例对象实例
    private static LazySingle single;

    // 获取单例对象的静态方法
    public static synchronized LazySingle getInstance() {
        // 如果实例为空，则创建新实例
        if (single == null) {
            single = new LazySingle();
        }
        return single;
    }
}

• 优点：

1. 延迟加载：只有在需要时才创建实例，避免了资源的浪费。
2. 灵活性高：可以根据需要进行实例化，适用于实例初始化较为复杂或耗时的情况。

• 缺点：

1. 性能受影响：由于需要在获取实例时进行同步操作，可能会影响性能。
2. 复杂度增加：需要考虑线程安全性，可能需要使用同步锁等机制，增加了代码复杂度。
3. 可能存在线程安全问题：在某些情况下，同步机制可能会引入死锁等问题，需要谨慎设计。

DCL双重检测锁

public class DoubleCheckLockSingle {
    // 使用volatile关键字确保instance在多线程环境下的可见性
    private volatile static DoubleCheckLockSingle instance;

    // 私有构造方法，避免外部直接实例化对象
    private DoubleCheckLockSingle() {
        // 私有构造方法
    }

    // 获取单例对象的静态方法
    public static DoubleCheckLockSingle getInstance() {
        // 第一次检查，避免不必要的同步
        if (instance == null) {
            // 同步块，确保在多线程环境下只有一个线程创建实例
            synchronized (DoubleCheckLockSingle.class) {
                // 第二次检查，防止多个线程同时进入同步块后重复创建实例
                if (instance == null) {
                    instance = new DoubleCheckLockSingle();
                }
            }
        }
        return instance;
    }
}

• 优点：

优点：

1. 延迟加载：只有在需要时才创建实例，避免了资源的浪费。
2. 线程安全：通过双重检查锁机制，在多线程环境下保证了线程安全性。
3. 性能较好：相比简单的懒汉式单例，双重检查锁在保证线程安全的同时减少了不必要的同步开销。

• 缺点：

1. 实现复杂：双重检查锁的实现较为复杂，需要考虑到多线程并发情况下的各种细节，容易出错。
2. 可能存在指令重排问题：在某些情况下，由于指令重排的影响，可能会导致获取到未完全初始化的实例。
3. 不适用于早期JDK版本：在早期的JDK版本中，由于JVM对volatile关键字的实现问题，可能会导致DCL失效。

在实际应用中，双重检查锁单例模式适用于需要延迟加载且对性能要求较高的情况，但需要谨慎考虑线程安全和实现复杂度。

静态内部类

public class StaticInnerClazzSingle {

    // 私有化构造方法，避免外部直接实例化
    private StaticInnerClazzSingle() {
        // 初始化操作
    }

    // 静态内部类，利用类加载机制实现延迟加载
    private static class SingletonHolder {
        private static final StaticInnerClazzSingle INSTANCE = new StaticInnerClazzSingle();
    }

    // 获取单例实例的方法
    public static StaticInnerClazzSingle getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

• 优点

1. 线程安全：利用类加载机制保证了线程安全，无需额外的同步措施。
2. 延迟加载：只有在 getInstance() 方法被调用时才会加载内部类并初始化单例对象，实现了延迟加载。
3. 简洁高效：代码简洁清晰，利用静态内部类的特性实现单例，高效且易于理解。

• 缺点

1. 不适用于非静态字段初始化：静态内部类只能访问外部类的静态成员，无法直接访问外部类的非静态成员。
2. 可能过于晦涩：对于不熟悉静态内部类机制的开发人员，可能会造成理解上的困难。
3. 无法传递参数：静态内部类实现的单例无法传递参数，因为在类加载时就初始化实例。

总体来说，静态内部类实现的单例模式是一种优雅且高效的实现方式，适合大多数情况下的单例需求，尤其适用于需要延迟加载且对线程安全有要求的场景。

枚举式单例模式

枚举类型是线程安全的，且只会加载一次。设计者充分的利用的这个特性来实现单例模式。且枚举模式不会被破坏，即不会因为反射而破坏这个实现

public enum EnumSingle {
    INSTANCE; // 单例实例

    // 枚举类的构造方法默认私有，保证外部无法实例化
    private EnumSingle() {
        // 初始化操作
    }

    // 获取单例实例的方法
    public static EnumSingle getInstance() {
        return INSTANCE;
    }
}

• 优点：

1. 线程安全：枚举类型在Java中天然线程安全，保证了单例的唯一性。
2. 避免反射和序列化问题：枚举类型在序列化和反序列化过程中会自动处理实例化，避免反射攻击和序列化破坏单例的问题。
3. 防止多次实例化：枚举类只能被实例化一次，避免了多次实例化的可能性。

• 缺点：

1. 无法懒加载：枚举类在类加载时就会被实例化，无法实现延迟加载。
2. 无法传递参数：枚举类的构造方法无法传递参数，因为枚举实例在类加载时就被初始化。
3. 不灵活：枚举类型本质上是类，无法继承其他类或实现其他接口，限制了扩展性。

总体来说，枚举方式实现单例模式是一种简洁高效且安全的方式，适合大多数单例需求，特别是在需要线程安全和避免反射攻击的情况下。然而，如果需要延迟加载或传递参数，枚举方式可能不适用。

存在的问题和解决方案

1. 破坏单例模式：
   除了枚举模式外，可以使用序列化和反射可以破坏单例模式。
   序列化原理： 反序列化读取对象是对象的copy。
   序列化和反序列化demo比较麻烦，笔者就不贴代码了，有兴趣的小伙伴可以自己尝试下。

/**
 * 反射破坏单例 以StaticInnerClazzSingle为例
 * 1. 获取StaticInnerClazzSingle类的Class对象。
 * 2. 获取该类的无参构造函数，并设置其可访问性。
 * 3. 通过构造函数创建一个新的HungrySingle实例。
 */
 	// 获取StaticInnerClazzSingle类的Class对象
	Class clazz = StaticInnerClazzSingle.class; 
	// 获取类的无参构造器
	Constructor cons = clazz.getDeclaredConstructor(); 
	// 设置构造器可访问
	cons.setAccessible(true); 
	// 利用构造器创建实例
	StaticInnerClazzSingle single = (StaticInnerClazzSingle) cons.newInstance(); 

2. 解决方法

// 当进行反序列化时，会自动调用该方法，将方法的返回值返回
public Object readResolve() {
	return SingletonHolder.INSTANCE;
}
// 反射破坏解决办法
private static boolean flag = false；
// 私有构造方法
private StaticInnerClazzSingle() {
	if (flag) {
		throw new RuntimeException("不能创建多个异常");
	}
	// 将flag设置为true
	flag = true；
}

典型的单例模式

Runtime 饿汉式单例模式