饿汉式在类加载时创建实例，线程安全但不支持懒加载；2. 懒汉式在首次调用时创建实例，支持懒加载但线程不安全；3. 线程安全的懒汉式通过synchronized实现线程安全和懒加载，但性能较低；4. 双重检查锁通过volatile和同步块实现高效线程安全与懒加载，实现较复杂；5. 静态内部类利用类加载机制实现线程安全和懒加载，推荐使用；6. 枚举实现线程安全且防止反射和序列化攻击，但不支持懒加载；防御反射攻击可在构造方法中检查实例是否存在并抛出异常，枚举单例天然防止反射攻击；单例模式通过类加载机制或同步手段保证多线程环境下的线程安全；单例模式限制一个类仅有一个实例并提供全局访问点，而工厂模式封装对象创建过程，两者关注点不同，单例控制实例数量，工厂抽象创建逻辑，工厂模式可创建单例对象，但二者本质不同，完整结束。
Java单例模式的核心在于确保一个类只有一个实例，并提供一个全局访问点。实现这一点，需要控制类的实例化过程。
解决方案
Java中实现单例模式有多种方法，各有优劣，选择哪种取决于具体场景的需求，比如是否需要懒加载、线程安全等。
立即学习“Java免费学习笔记（深入）”；
1. 饿汉式（Eager Initialization）
这是最简单的实现方式，在类加载时就完成了实例化。
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {
// 私有构造方法，防止外部实例化
}
public static Singleton getInstance() {
return instance;
}
public void doSomething() {
System.out.println("Singleton is doing something...");
}
}- 优点： 实现简单，线程安全（因为在类加载时完成实例化）。
- 缺点： 不是懒加载，如果单例对象一直没有被用到，会造成资源浪费。
2. 懒汉式（Lazy Initialization）
在第一次调用
getInstance()方法时才进行实例化。
public class Singleton {
private static Singleton instance;
private Singleton() {
// 私有构造方法，防止外部实例化
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
public void doSomething() {
System.out.println("Singleton is doing something...");
}
}- 优点： 实现了懒加载，只有在需要的时候才会创建实例。
- 缺点： 线程不安全，在多线程环境下可能会创建多个实例。
3. 线程安全的懒汉式（Synchronized Lazy Initialization）
为了解决懒汉式的线程安全问题，可以对
getInstance()方法进行同步。
public class Singleton {
private static Singleton instance;
private Singleton() {
// 私有构造方法，防止外部实例化
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
public void doSomething() {
System.out.println("Singleton is doing something...");
}
}- 优点： 线程安全，实现了懒加载。
-
缺点： 效率较低，每次调用
getInstance()
方法都需要进行同步，开销较大。
4. 双重检查锁（Double-Checked Locking）
一种更高效的线程安全懒汉式实现。
public class Singleton {
private volatile static Singleton instance;
private Singleton() {
// 私有构造方法，防止外部实例化
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
public void doSomething() {
System.out.println("Singleton is doing something...");
}
}- 优点： 线程安全，实现了懒加载，效率较高。
-
缺点： 实现较为复杂，需要注意
volatile
关键字的使用，防止指令重排序导致的问题。
5. 静态内部类（Static Inner Class）
利用类加载机制保证线程安全和懒加载。
public class Singleton {
private Singleton() {
// 私有构造方法，防止外部实例化
}
private static class SingletonHolder {
private static final Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
public void doSomething() {
System.out.println("Singleton is doing something...");
}
}- 优点： 线程安全，实现了懒加载，实现简单，推荐使用。
- 缺点： 无。
6. 枚举（Enum）
最简洁的实现方式，可以防止反射攻击和序列化问题。
public enum Singleton {
INSTANCE;
public void doSomething() {
System.out.println("Singleton is doing something...");
}
}- 优点： 线程安全，防止反射攻击和序列化问题，实现简单。
- 缺点： 不能懒加载。
单例模式中的反射攻击如何防御？
反射机制允许在运行时检查和修改类的行为。对于单例模式，这意味着可以通过反射创建多个实例，破坏单例的特性。防御反射攻击的主要方法是在构造方法中进行检查，如果已经存在实例，则抛出异常。例如：
public class Singleton {
private static Singleton instance;
private Singleton() {
if (instance != null) {
throw new IllegalStateException("Singleton instance already exists.");
}
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}这样，即使通过反射调用构造方法，也会因为抛出异常而无法创建新的实例。枚举单例天然防止反射攻击，因为Java语言规范禁止通过反射创建枚举实例。
单例模式在多线程环境下如何保证线程安全？
多线程环境是单例模式需要重点考虑的场景。线程安全意味着在多个线程同时访问单例对象时，不会出现数据不一致或者创建多个实例的情况。上述的几种实现方式中，饿汉式、静态内部类和枚举天生就是线程安全的。懒汉式需要进行同步处理，才能保证线程安全。双重检查锁是一种常用的优化手段，可以减少同步的开销。
单例模式与工厂模式的区别是什么？
单例模式和工厂模式是两种不同的设计模式，虽然它们都涉及到对象的创建，但解决的问题和应用场景不同。单例模式关注的是如何保证一个类只有一个实例，并提供全局访问点。工厂模式关注的是如何将对象的创建过程封装起来，使得客户端不需要知道具体类的创建细节。简单来说，单例模式是限制类的实例化数量，而工厂模式是抽象类的实例化过程。工厂模式可以创建单例对象，但单例模式不一定需要通过工厂模式来创建。
