如何实现Java中的单例模式？举例说明。

Java中的单例模式（Singleton Pattern）是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。实现单例模式有多种方法，下面介绍几种常见的实现方式。

饿汉式单例（Eager Initialization）

饿汉式单例在类加载时就创建实例，这种方式简单但在类加载时即创建实例，可能会带来资源浪费问题。

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {
        // private constructor to prevent instantiation
    }
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

懒汉式单例（Lazy Initialization）

懒汉式单例在第一次调用getInstance()方法时才创建实例。这种方式懒加载但线程不安全。

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {
        // private constructor to prevent instantiation
    }
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

线程安全的懒汉式单例

通过在getInstance()方法上加同步关键字sychronized，确保线程安全，但会影响性能。

public class ThreadSafeLazySingleton {
    private static ThreadSafeLazySingleton instance;
    private ThreadSafeLazySingleton() {
        // private constructor to prevent instantiation
    }
    public static synchronized ThreadSafeLazySingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeLazySingleton();
        }
        return instance;
    }
}

双重检查锁（Double-Checked Locking）

双重检查锁在减少同步开销的同时确保线程安全，是一种高效的实现方式。

public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;
    private DoubleCheckedLockingSingleton() {
        // private constructor to prevent instantiation
    }
    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

静态内部类单例（Bill Pugh Singleton）

利用静态内部类特点实现懒加载且线程安全，是推荐的实现方式之一。

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {
        // private constructor to prevent instantiation
    }
    private static class SingletonHelper {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }
    public static StaticInnerClassSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

枚举单例

枚举类型保证了线程安全并且防止反序列化时创建新的对象，是实现单例模式的最佳方式之一。

public enum EnumSingleton {
    INSTANCE;
    public void doSomething() {
        // method implementation
    }
}

总结

以上几种方法各有优缺点：

1. 饿汉式单例：简单但可能浪费资源。
2. 懒汉式单例：懒加载但线程不安全。
3. 线程安全的懒汉式单例：线程安全但性能差。
4. 双重检查锁单例：线程安全且性能较好。
5. 静态内部类单例：推荐使用，懒加载且线程安全。
6. 枚举单例：最优雅和推荐的实现方式，天然线程安全且防止反序列化创建新实例。

根据具体需求选择合适的实现方式，以满足性能和资源管理的要求。