单例设计模式

        单例设计模式（Singleton Design Pattern）是一种常用的软件设计模式，它确保一个类在整个应用程序的生命周期中只会产生一个实例，并提供一个全局访问点来获取这个唯一的实例。单例模式的目标是控制类的实例化过程，使得无论何时何地访问这个类的实例时，得到的都是同一个对象。

单例模式的核心特征如下：

1. 唯一实例：单例类只能有一个实例，并且自行确保这个实例的唯一性。

2. 自我实例化：单例类负责创建自身的唯一实例，并且隐藏其构造函数，防止外部通过常规的new操作符创建新实例。

3. 全局访问点：单例类提供一个公共的静态方法，以便其他对象获取该类的唯一实例。这个方法通常被称为“getInstance”。

在Java中，单例模式的实现通常有以下几种方式：

• 饿汉式（Eager Initialization）：类加载时立即创建实例，静态成员变量直接初始化。

          饿汉式（静态常量）

public class Singleton {
    private volatile static Singleton instance = new Singleton(); // 使用volatile关键字防止指令重排序

    private Singleton() {}
    
    public static Singleton getInstance() {
        return instance;
    }
}

         这种方式写法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题。

         饿汉式（静态代码块）

public class Singleton {
    private volatile static Singleton instance = null; 

    private Singleton() {}
    
    static{
    	instance = new Singleton();
    }
    
    public static Singleton getInstance() {
        return instance;
    }
}

         这种方式写法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题。

• 懒汉式（Lazy Initialization）：延迟加载，在第一次调用获取实例的方法时才真正创建实例。为保证线程安全，可能需要加锁（如synchronized关键字）或使用双重检查锁定（Double-Checked Locking）。

        懒汉式（线程不安全）

public class Singleton {
    private static Singleton instance; // 创建Singleton类型的静态实例

    private Singleton() {} // 私有构造函数防止外部直接实例化

    public static Singleton getInstance() {
        if (instance == null) { // 第一次调用时实例化
            instance = new Singleton();
        }
        return instance;
    }
}

        这种实现方式简单直观，但是线程不安全，如果在多线程环境下可能会创建多个实例。 

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

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

        这种方式解决了线程安全问题，但每次获取实例时都需要进行同步，性能较低。

        双重检查锁定（DCL，线程安全，效率较高）

public class Singleton {
    private volatile static Singleton instance; // 使用volatile关键字防止指令重排序

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查，只有第一次创建时才进入同步块
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

        这种方式既保证了线程安全，又避免了每次都进行同步带来的性能损耗。 

• 静态内部类：利用类加载机制来保证线程安全和懒加载。

public class Singleton {
    private Singleton() {}

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

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

            这种方式利用了类加载机制来保证线程安全，且能保证Singleton实例在首次加载类时就完成初始化，称为静态内部类单例模式。 

• 枚举（Enum）：Java枚举类型天生就是单例的，创建简单且线程安全，但相对较新，不是所有的编程环境都支持。

public enum Singleton {
    INSTANCE;

    // 实例方法
    public void doSomething() {
        // ...
    }
}

// 获取单例实例
Singleton singleton = Singleton.INSTANCE;
singleton.doSomething();

        这是《Effective Java》作者Joshua Bloch推荐的单例实现方式，不仅能防止反射攻击，还提供了天然的序列化机制，同时也是线程安全的。 

        每种实现方式都有其适用场景和优缺点，开发者需要根据实际需求选择合适的方式来实现单例模式。单例模式常应用于日志系统、数据库连接池、缓存、线程池、工具类等场合，这些场景下往往只需要一个共享的全局实例。然而，过度使用单例模式可能带来全局状态过多、测试困难等问题，因此在设计时需要权衡利弊。