Java的单例

1. 懒汉式（Lazy Initialization）

这种方式在第一次调用时创建实例，延迟实例的创建。

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造函数
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

2. 线程安全的懒汉式

通过同步方法来保证线程安全。

public class ThreadSafeLazySingleton {
    private static ThreadSafeLazySingleton instance;

    private ThreadSafeLazySingleton() {
        // 私有构造函数
    }

    public static synchronized ThreadSafeLazySingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeLazySingleton();
        }
        return instance;
    }
}

3. 双重检查锁定（Double-Checked Locking）

通过双重检查来减少同步的开销。

public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {
        // 私有构造函数
    }

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

4. 饿汉式（Eager Initialization）

在类加载时就创建实例，简单且线程安全。

public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {
        // 私有构造函数
    }

    public static EagerSingleton getInstance() {
        return instance;
    }
}

5. 静态内部类（Static Inner Class）

利用类加载机制确保单例的延迟初始化和线程安全。

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {
        // 私有构造函数
    }

    private static class SingletonHolder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

6. 枚举单例

使用枚举来实现单例，简洁且天然支持序列化。

public enum EnumSingleton {
    INSTANCE;

    public void someMethod() {
        // 示例方法
    }
}