深入理解GoF设计模式之单例模式

单例模式是一种广泛使用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。本文将详细介绍单例模式的概念、实现方式及其优缺点。

单例模式的核心目标是确保一个类的实例在整个应用程序中始终唯一。为了实现这一点，通常需要将类的构造函数设为私有，并在类内部创建实例，然后通过一个公共的静态方法提供对该实例的访问。这种方式可以有效避免因频繁创建和销毁实例而导致的性能开销，但也存在一些缺点，比如违反了单一职责原则，即一个类应该只有一个引起变化的原因。

1. 饿汉式

饿汉式单例是最简单的实现方式之一。在这种模式下，类的实例在类加载时就已经创建好了，因此是线程安全的。然而，这种方式可能导致资源的浪费，因为即使实例从未被使用，也会占用内存。

public class SingletonDemo1 {
    private static final SingletonDemo1 instance = new SingletonDemo1("我是饿汉式的单例");
    private String description;

    private SingletonDemo1(String description) {
        this.description = description;
    }

    public void getInfo() {
        System.out.println(description);
    }

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

测试结果如下所示：

2. 懒汉式

懒汉式单例实现了延迟加载，即在首次需要实例时才创建。这种方式可以节省内存，但默认情况下不是线程安全的。可以通过同步方法来解决线程安全问题，但这会影响性能。

public class SingletonDemo2 {
    private static SingletonDemo2 instance = null;
    private String description;

    private SingletonDemo2(String description) {
        this.description = description;
    }

    public void getInfo() {
        System.out.println(description);
    }

    public static synchronized SingletonDemo2 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo2("我是线程安全的懒汉式单例");
        }
        return instance;
    }
}

测试结果如下所示：

3. 基于DCL的双重检查锁

基于DCL的双重检查锁是一种既实现了延迟加载又保证了线程安全的单例实现方式。它通过两次检查实例是否为空来减少不必要的同步操作，提高性能。在实现中，静态变量instance必须使用volatile关键字修饰，以防止指令重排序问题。

public class SingletonDemo4 {
    private static volatile SingletonDemo4 instance = null;
    private String description;

    private SingletonDemo4(String description) {
        this.description = description;
    }

    public void getInfo() {
        System.out.println(description);
    }

    public static SingletonDemo4 getInstance() {
        if (instance == null) {
            synchronized (SingletonDemo4.class) {
                if (instance == null) {
                    instance = new SingletonDemo4("我是基于DCL的线程安全的单例");
                }
            }
        }
        return instance;
    }
}

测试结果如下：

4. 基于静态内部类的单例

基于静态内部类的单例实现方式既实现了延迟加载，又是线程安全的。这种方式利用了Java类加载机制，确保实例在首次调用getInstance方法时才被创建。

public class SingletonDemo5 {
    private String description;

    private SingletonDemo5(String description) {
        this.description = description;
    }

    public void getInfo() {
        System.out.println(description);
    }

    private static class SingletonDemo5Holder {
        private static final SingletonDemo5 instance = new SingletonDemo5("我是基于静态内部类的线程安全的单例");
    }

    public static SingletonDemo5 getInstance() {
        return SingletonDemo5Holder.instance;
    }
}

测试结果如下所示：

5. 基于枚举的单例

基于枚举的单例实现方式简洁且线程安全。枚举的构造器默认是私有的，这确保了实例的唯一性。这种方式适用于不需要延迟加载的场景。

public enum SingletonDemo6 {
    INSTANCE("我是枚举法的单例");
    private String description;

    SingletonDemo6(String description) {
        this.description = description;
    }

    public void getInfo() {
        System.out.println(description);
    }
}

测试结果如下：

1. Head First 设计模式 弗里曼著