单例模式的核心目标是确保一个类在程序运行期间只有一个实例，并且该实例可以被全局访问。在Java中，实现单例模式需要私有化构造方法，避免外部通过new关键字创建实例，同时提供一个静态方法供外部获取唯一实例。在多线程场景下，还需要额外处理并发问题，防止多个线程同时创建实例导致单例失效。
1. 饿汉式单例（线程安全）
饿汉式是最简单的单例实现方式，在类加载阶段就完成实例的初始化，因此天生具备线程安全性，因为类加载过程是线程安全的。
public class HungrySingleton {
// 类加载时就初始化实例
private static final HungrySingleton INSTANCE = new HungrySingleton();
// 私有化构造方法，防止外部创建实例
private HungrySingleton() {}
// 提供全局访问点
public static HungrySingleton getInstance() {
return INSTANCE;
}
}
这种写法的优点是实现简单，线程安全，获取实例的效率高；缺点是不管是否使用该实例，类加载时都会创建实例，可能造成资源浪费，如果实例初始化过程比较耗时，还会拖慢类加载速度。
2. 懒汉式单例（非线程安全）
懒汉式的核心思想是延迟加载，只有在第一次调用获取实例的方法时才创建实例，避免了饿汉式的资源浪费问题，但基础写法在多线程环境下是不安全的。
public class LazySingleton {
private static LazySingleton instance;
private LazySingleton() {}
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
当多个线程同时调用getInstance()方法时，可能出现多个线程都判断instance为null的情况，从而导致创建多个实例，破坏单例规则，因此这种写法不适合多线程场景。
3. 同步方法懒汉式（线程安全）
要解决基础懒汉式的线程安全问题，最简单的方式是在获取实例的方法上添加synchronized关键字，保证同一时间只有一个线程能执行该方法。
public class SynchronizedSingleton {
private static SynchronizedSingleton instance;
private SynchronizedSingleton() {}
// 同步方法，保证线程安全
public static synchronized SynchronizedSingleton getInstance() {
if (instance == null) {
instance = new SynchronizedSingleton();
}
return instance;
}
}
这种写法确实能保证线程安全，但每次调用getInstance()方法都需要加锁，即使实例已经创建完成，还是会有锁竞争的开销，性能较差，不适合高并发场景。
4. 双重检查锁单例（线程安全）
双重检查锁是对同步方法懒汉式的优化，既保证了线程安全，又减少了锁的开销，只有在实例未创建时才会加锁。
public class DoubleCheckSingleton {
// 使用volatile关键字防止指令重排
private static volatile DoubleCheckSingleton instance;
private DoubleCheckSingleton() {}
public static DoubleCheckSingleton getInstance() {
// 第一次检查，实例已存在则直接返回，无需加锁
if (instance == null) {
synchronized (DoubleCheckSingleton.class) {
// 第二次检查，防止多个线程同时通过第一次检查后重复创建实例
if (instance == null) {
instance = new DoubleCheckSingleton();
}
}
}
return instance;
}
}
这里instance变量必须添加volatile修饰，因为instance = new DoubleCheckSingleton()这行代码不是原子操作，会分为分配内存、初始化对象、将引用指向内存地址三步，可能发生指令重排，导致其他线程拿到未初始化完成的实例。这种写法是很多场景下的首选，兼顾了性能和线程安全。
5. 静态内部类单例（线程安全）
静态内部类单例利用了Java类加载的特性，静态内部类不会在外部类加载时加载，只有第一次调用获取实例的方法时才会加载静态内部类，同时类加载过程是线程安全的，因此也能保证单例的线程安全。
public class InnerClassSingleton {
private InnerClassSingleton() {}
// 静态内部类，持有外部类的唯一实例
private static class SingletonHolder {
private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
}
public static InnerClassSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
这种写法既实现了延迟加载，又保证了线程安全，同时没有加锁的性能开销，实现也比较简洁，是推荐的单例实现方式之一。
6. 枚举单例（线程安全）
枚举单例是《Effective Java》中推荐的实现方式，利用枚举的特性保证实例唯一，同时天然支持序列化，不会因为反序列化创建新的实例。
public enum EnumSingleton {
INSTANCE;
// 可以添加自定义的方法
public void doSomething() {
System.out.println("执行单例实例的方法");
}
}
获取实例时直接通过EnumSingleton.INSTANCE即可，这种写法实现最简单，而且能避免反射攻击和序列化问题，是最安全的单例实现方式，但可读性相对其他写法稍弱，部分开发者不太习惯这种写法。
不同实现方式对比
| 实现方式 | 线程安全 | 延迟加载 | 性能 | 防反射/序列化破坏 |
|---|---|---|---|---|
| 饿汉式 | 是 | 否 | 高 | 否 |
| 基础懒汉式 | 否 | 是 | 高 | 否 |
| 同步方法懒汉式 | 是 | 是 | 低 | 否 |
| 双重检查锁 | 是 | 是 | 较高 | 否 |
| 静态内部类 | 是 | 是 | 高 | 否 |
| 枚举 | 是 | 否 | 高 | 是 |
在实际开发中，如果没有特殊需求，优先推荐静态内部类单例或者枚举单例，前者兼顾延迟加载和性能，后者安全性最高。如果确定实例一定会被使用，饿汉式也是不错的选择，实现简单不易出错。