设计模式之单例模式

定义

单例模式是一种创建型设计模式，目的在于保证一个类仅有一个实例，并通过一个全局访问点提供对该实例的访问。这种模式的优势在于，它有助于在系统中维护某些资源的唯一性，例如配置信息、数据库连接等，防止资源的重复创建和浪费。为了实现单例模式，我们需要注意以下几个关键点：

• 私有构造函数：确保外部代码不能通过常规方式创建该类的实例（如通过new创建实例）。
• 静态实例属性：用于保存单一实例的引用，并确保其唯一性。
• 公有静态方法：提供一个访问点，使外部能够获取到唯一的实例。
• 线程安全措施：在多线程环境中确保实例的唯一性不受影响。

实现方式

饿汉式（静态常量）

饿汉式实现方式在类加载时就完成了实例的初始化，因此它是线程安全的。但这种方式可能导致在不需要使用实例时就提前占用了系统资源。具体的代码实现如下所示：

public class Singleton {  
    // 静态常量，类加载时就完成了初始化，避免了线程同步问题  
    private static final Singleton INSTANCE = new Singleton();  
    private Singleton() {}  
  
    // 静态方法，提供全局访问点  
    public static Singleton getInstance() {  
        return INSTANCE;  
    }  
}

有些人可能不赞同这种立即初始化的做法，因为它不支持懒加载。在实例占用大量资源或初始化时间较长的情况下，提前创建实例可能会造成资源的浪费。理想情况下，我们应该仅在需要时才创建实例。然而，如果初始化过程耗时，那么延迟到真正需要时才进行初始化可能会影响系统性能，例如，在处理客户端请求时进行初始化可能会导致响应延迟甚至超时。因此，通过提前在程序启动时完成这些耗时的初始化操作（即饿汉式实现），我们可以避免在程序运行时对性能产生负面影响。

此外，根据fail-fast原则（有问题及早暴露），我们更倾向于在程序启动时就创建这些资源密集型的实例。这样做可以在资源不足时（例如内存溢出）立即发现问题，并促使开发者尽快解决，而不是等到程序运行后才因为资源问题导致系统崩溃，这样会严重影响系统的可靠性和可用性。

懒汉式（线程不安全）

懒汉式实现方式在第一次调用getInstance()方法时才创建实例，因此它支持懒加载。但在多线程环境下，这种实现方式可能导致多个实例被创建。具体的代码实现如下所示：

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

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

上述的懒汉式实现在多线程环境中不具备线程安全性。为了解决这个问题，我们可以在getInstance()方法中加入synchronized关键字，确保在多线程条件下只创建一个实例。具体的代码实现如下所示：

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

然而，这种做法会牺牲一定的性能，因为每次调用getInstance()时都会执行同步操作，增加了方法调用的延迟。如果单例类的使用频率不高，这种同步开销或许是可以接受的。然而，在频繁使用该单例类的场景下，频繁的加锁、解锁操作以及降低的并发性能可能会导致严重的性能瓶颈，这时同步的懒汉式实现便不太合适了。

双重检查锁定

双重检查锁定是一种更高效的懒汉式实现方式。它只在第一次实例化时进行同步，之后直接返回已创建的实例。同时，通过使用volatile关键字确保实例在多线程环境中的可见性。具体的代码实现如下所示：

public class Singleton {  
    // 使用volatile关键字确保instance在多线程环境中的可见性  
    private volatile static Singleton instance;  
    private Singleton() {}  
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (Singleton.class) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

注意，之所以使用volatile关键字，这是因为instance = new Singleton();这行代码并不是原子的，它包含三个步骤：分配对象的内存空间、初始化对象、将内存空间的地址赋给变量instance。如果不使用volatile，JVM可能会进行指令重排序，导致其他线程在对象还没有完全初始化之前就访问了它。

静态内部类

静态内部类实现方式利用了Java的类加载机制。当外部类被加载时，并不会初始化静态内部类。只有在调用getInstance()方法时，静态内部类才会被加载并初始化其中的实例。这种方式既实现了懒加载，又保证了线程安全。具体的代码实现如下所示：

public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
 
    private Singleton() {}  
    
    public static Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}

枚举

枚举（Enum）类型在Java中是一种特殊的类，它包含了固定数量的常量。由于枚举类型的特殊性和Java语言规范的规定，枚举类型在Java中天然就是线程安全的，并且是单例的。枚举实现单例模式的方式非常简单且高效，因为枚举类型在JVM中是通过类加载机制来保证其线程安全和单例特性的。首先，你需要创建一个枚举类，该类只包含一个枚举值，这个枚举值实际上就是你的单例对象。具体的代码实现如下所示：

public enum Singleton {  
    INSTANCE;  
  
    // 你可以在这里添加你需要的方法
    public void doSomething() {  
        // 实现你的业务逻辑
    }
}

public static void main(String[] args) {
    Singleton instance = Singleton.INSTANCE;
    instance.doSomething();
}

总结

单例模式是一种简单而实用的设计模式，通过确保一个类只有一个实例并提供全局访问点，可以有效地管理系统中的某些资源。在实际项目中，我们应根据具体场景和需求选择合适的实现方式。同时，也需要注意单例模式的滥用，避免过度使用导致系统结构复杂、难以维护。