单例模式的几种实现方式

单例模式是一种常用的设计模式，它能够保证一个类在任何情况下只能创建一个实例对象，可以避免出现多个实例对象导致的资源浪费和数据不一致等问题。单例模式的实现方式有以下几种。

饿汉式单例

饿汉式单例是指在类加载阶段就创建了一个单例对象，保证了线程安全，但可能浪费内存资源。它的实现方式如下：

public class Singleton {
    // 创建一个私有的 Singleton 实例，使用 static final 关键字确保只会被创建一次
    private static final Singleton instance = new Singleton();
    
    // 将构造函数设为私有，禁止外部创建新的实例
    private Singleton() {}
    
    // 提供一个公有的访问方法，返回唯一的 Singleton 实例
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式单例

懒汉式单例是指在第一次使用时才创建单例对象，可以节省内存资源，但需要考虑线程安全和效率问题。它的实现方式有以下几种。

线程不安全懒汉式

/**
 * 懒汉式单例模式，线程不安全的实现方式。
 */
public class Singleton {
    private static Singleton instance = null;

    private Singleton() {}

    /**
     * 获取 Singleton 实例的公有静态方法，第一次调用时创建实例。
     * @return Singleton 实例
     */
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

线程安全懒汉式（同步方法）

/**
 * 懒汉式单例模式，在多线程环境下保证线程安全的实现方式。
 */
public class Singleton {
    private static Singleton instance = null;

    private Singleton() {}

    /**
     * 获取 Singleton 实例的公有静态方法，第一次调用时创建实例。
     * @return Singleton 实例
     */
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

线程安全懒汉式（双重检查锁）

/**
 * 懒汉式单例模式，使用双重检查锁保证线程安全的实现方式。
 */
public class Singleton {
    private static volatile Singleton instance = null;

    private Singleton() {}

    /**
     * 获取 Singleton 实例的公有静态方法，第一次调用时创建实例。
     * @return Singleton 实例
     */
    public static Singleton getInstance() {
        // 双重检查锁
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

其中，volatile 关键字用于保证在多线程环境下，instance 对象的初始化操作与其他指令不会发生重排序，从而避免线程安全问题

静态内部类单例

静态内部类单例是指使用静态内部类来创建单例对象，只有在第一次使用内部类时才会创建单例对象。这种方式既可以保证线程安全，又可以实现延迟加载，而且代码简洁。它的实现方式如下：

/**
 * 静态内部类单例模式，保证线程安全的懒加载单例实现方式。
 */
public class Singleton {
    private Singleton() {}

    /**
     * 静态内部类，用于创建 Singleton 实例。
     * 类加载机制保证了在第一次使用内部类时，Singleton 实例会被创建。
     */
    private static class Inner {
        static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 获取 Singleton 实例的公有静态方法，第一次调用时创建实例。
     * @return Singleton 实例
     */
    public static Singleton getInstance() {
        return Inner.INSTANCE;
    }
}

枚举单例

枚举单例是指使用枚举类型来创建单例对象，枚举类型的特性保证了只能创建一个实例对象。它的实现方式如下：

/**
 * 枚举式单例模式，保证线程安全的实现方式。
 */
public enum Singleton {
    INSTANCE;

    // 枚举类的默认构造方法是私有的，保证只有一个实例
    private Singleton() {}

    /**
     * 对外提供一个可供访问 Singleton 实例的方法
     */
    public void doSomething() {
        // ...
    }
}