单例模式：
- 定义：确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。为了防止出现重复的创建。
单例模式是JAVA中最简单的设计模式之一。属于创建型设计模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有一个对象被创建。这个类提供了访问唯一对象的方法，可以直接访问，不需要new。
饿汉式：程序起始就初始化对象。
public class HungrySingle {
// 私有空参构造方法，让初始化无法轻易被别人调用 (反射可以进行调用)
private HungrySingle() {}
// 在类中创建该类对象
private static final HungrySingle single = new HungrySingle();
// 提供公共的访问方式，提供外接进行访问
public static HungrySingle getInstance() {return single;}
}
- 优点：
- 线程安全：由于实例在类加载时就创建，所以不存在多线程环境下的线程安全问题。
- 简单易用：实现简单，不需要考虑多线程同步等复杂性。
- 缺点：
- 浪费资源：在程序启动时即创建实例，如果该实例在后续程序运行中很少被使用，就会造成资源浪费。
- 灵活性受限：无法实现延迟加载，不适合在实例创建过程中需要执行复杂操作的情况。
- 可能造成加载缓慢：如果实例初始化较为耗时，会导致程序启动较慢。
懒汉式：被外部类调用才创建实例
public class LazySingle {
// 声明私有构造方法
private LazySingle(){};
// 单例对象实例
private static LazySingle single;
// 获取单例对象的静态方法
public static synchronized LazySingle getInstance() {
// 如果实例为空，则创建新实例
if (single == null) {
single = new LazySingle();
}
return single;
}
}
- 优点：
- 延迟加载：只有在需要时才创建实例，避免了资源的浪费。
- 灵活性高：可以根据需要进行实例化，适用于实例初始化较为复杂或耗时的情况。
- 缺点：
- 性能受影响：由于需要在获取实例时进行同步操作，可能会影响性能。
- 复杂度增加：需要考虑线程安全性，可能需要使用同步锁等机制，增加了代码复杂度。
- 可能存在线程安全问题：在某些情况下，同步机制可能会引入死锁等问题，需要谨慎设计。
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;
}
}
- 优点：
优点：
- 延迟加载：只有在需要时才创建实例，避免了资源的浪费。
- 线程安全：通过双重检查锁机制，在多线程环境下保证了线程安全性。
- 性能较好：相比简单的懒汉式单例，双重检查锁在保证线程安全的同时减少了不必要的同步开销。
- 缺点：
- 实现复杂：双重检查锁的实现较为复杂，需要考虑到多线程并发情况下的各种细节，容易出错。
- 可能存在指令重排问题：在某些情况下，由于指令重排的影响，可能会导致获取到未完全初始化的实例。
- 不适用于早期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;
}
}
- 优点
- 线程安全：利用类加载机制保证了线程安全，无需额外的同步措施。
- 延迟加载：只有在 getInstance() 方法被调用时才会加载内部类并初始化单例对象，实现了延迟加载。
- 简洁高效：代码简洁清晰，利用静态内部类的特性实现单例，高效且易于理解。
- 缺点
- 不适用于非静态字段初始化：静态内部类只能访问外部类的静态成员，无法直接访问外部类的非静态成员。
- 可能过于晦涩：对于不熟悉静态内部类机制的开发人员，可能会造成理解上的困难。
- 无法传递参数：静态内部类实现的单例无法传递参数，因为在类加载时就初始化实例。
总体来说，静态内部类实现的单例模式是一种优雅且高效的实现方式，适合大多数情况下的单例需求，尤其适用于需要延迟加载且对线程安全有要求的场景。
枚举式单例模式
枚举类型是线程安全的，且只会加载一次。设计者充分的利用的这个特性来实现单例模式。且枚举模式不会被破坏，即不会因为反射而破坏这个实现
public enum EnumSingle {
INSTANCE; // 单例实例
// 枚举类的构造方法默认私有，保证外部无法实例化
private EnumSingle() {
// 初始化操作
}
// 获取单例实例的方法
public static EnumSingle getInstance() {
return INSTANCE;
}
}
- 优点：
- 线程安全：枚举类型在Java中天然线程安全，保证了单例的唯一性。
- 避免反射和序列化问题：枚举类型在序列化和反序列化过程中会自动处理实例化，避免反射攻击和序列化破坏单例的问题。
- 防止多次实例化：枚举类只能被实例化一次，避免了多次实例化的可能性。
- 缺点：
- 无法懒加载：枚举类在类加载时就会被实例化，无法实现延迟加载。
- 无法传递参数：枚举类的构造方法无法传递参数，因为枚举实例在类加载时就被初始化。
- 不灵活：枚举类型本质上是类，无法继承其他类或实现其他接口，限制了扩展性。
总体来说，枚举方式实现单例模式是一种简洁高效且安全的方式，适合大多数单例需求，特别是在需要线程安全和避免反射攻击的情况下。然而，如果需要延迟加载或传递参数，枚举方式可能不适用。
存在的问题和解决方案
- 破坏单例模式：
除了枚举模式外，可以使用序列化和反射可以破坏单例模式。
序列化原理： 反序列化读取对象是对象的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();
- 解决方法
// 当进行反序列化时，会自动调用该方法，将方法的返回值返回
public Object readResolve() {
return SingletonHolder.INSTANCE;
}
// 反射破坏解决办法
private static boolean flag = false；
// 私有构造方法
private StaticInnerClazzSingle() {
if (flag) {
throw new RuntimeException("不能创建多个异常");
}
// 将flag设置为true
flag = true；
}
典型的单例模式
Runtime 饿汉式单例模式
