设计模式-单例模式

Java中的单例模式确保一个类只有一个实例，并提供一个全局访问点。以下是一个简单的单例模式的实现：

public class Singleton {
    // 创建 Singleton 类的一个对象
    private static Singleton instance = new Singleton();

    // 让构造函数为 private，这样该类就不会被实例化
    private Singleton() {}

    // 获取唯一可用的对象
    public static Singleton getInstance() {
        return instance;
    }

    public void showMessage() {
        System.out.println("Hello World!");
    }
}

在这个例子中，Singleton 类只有一个 Singleton 实例，并且 Singleton 类的构造函数是私有的，所以不能通过 new Singleton() 的方式创建新的实例。唯一获取 Singleton 类实例的方式是通过 Singleton.getInstance() 方法。

然后你可以这样使用：

public class SingletonPatternDemo {
    public static void main(String[] args) {
        // 不合法的构造函数
        // 编译时错误：构造函数 Singleton() 是不可见的
        // Singleton object = new Singleton();

        // 获取唯一可用的对象
        Singleton object = Singleton.getInstance();

        // 显示消息
        object.showMessage();
    }
}

这种方式适合单线程环境，但在多线程环境下，可能会创建多个实例。为了在多线程环境下也能保证只有一个实例，可以使用 "双重检查锁定" 来实现单例，这种方式既保证了唯一性，并且线程安全，又延迟了单例的初始化，只有在真正使用时才会初始化。

public class Singleton {
    // 使用 volatile 关键字保证多线程环境下的可见性
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        // 第一次检查：如果实例不存在，则进入同步块
        if (instance == null) {
            synchronized (Singleton.class) {
                // 第二次检查：如果实例不存在，则创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

在这个例子中，只有当 instance 为 null 时，才会进行同步。这就是 "双重检查锁定" 的名称的由来。这种方式既保证了线程安全，又比直接在 getInstance 方法上加同步更高效。