单例模式：保证一个类只有一个实例

单例模式：保证一个类只有一个实例

什么是单例模式？

在软件开发中，有些类只需要一个实例，比如数据库连接池、线程池等。单例模式就是一种设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。

实现单例模式的方法（最常见的五种）

1. 饿汉式

饿汉式是最简单的实现方式，它在类加载时就创建了实例，并且提供一个静态方法返回该实例。

/**
 * 单例模式 - 饿汉式
 *  优点：线程安全
 *  缺点：资源浪费
 */
public class Singleton1 {
    // 1. 声明并创建静态实例
    private static Singleton1 instance = new Singleton1();
    // 2. 构造器私有
    private Singleton1() {}
    // 3. 公有的静态方法，获取实例
    public static Singleton1 getInstance() {
        return instance;
    }
}

jdk源码中的 Runtime 就使用了这种方式实现单例模式

Runtime部分源码

public class Runtime {
	// 声明并创建静态实例
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class Runtime are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the Runtime object associated with the current
     *          Java application.
     */
     // 公有的静态方法，获取实例
    public static Runtime getRuntime() {
        return currentRuntime;
    }
	// 构造器私有
    /** Don't let anyone else instantiate this class */
    private Runtime() {}

2. 懒汉式

懒汉式是在第一次使用时才创建实例，它使用了延迟加载的方式。

/**
 * 单例模式 - 懒汉式
 * 优点：线程安全, 懒加载,避免了资源浪费
 * 缺点：在多线程环境下，每次调用getInstance()方法都需要进行同步，会影响性能
 */
public class Singleton2 {
    // 1. 声明静态实例
    private static Singleton2 instance;
    // 2. 构造器私有
    private Singleton2() {};
    // 3. 静态公有方法，获取实例，对该方法进行加synchronized进行线程同步
    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

3. 双检锁

双检锁是对懒汉式的改进，它使用了双重检查来提高性能。

/**
 * 单例模式 - 双重检索
 * 优点：线程安全、懒加载、性能好
 */
public class Singleton3 {
    // 1. 声明私有实例，使用volatile修饰，保证可见性、防止指令重排
    private static volatile Singleton3 instance;
    // 2. 构造器私有
    private Singleton3() {};
    // 3. 静态公有方法，获取实例，加入双重检查代码
    public static Singleton3 getInstance() {
        if (instance == null) {
            synchronized (Singleton3.class) {
                if (instance == null) { // 双重检查
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
}

4. 静态内部类

静态内部类方式是利用了类加载机制来保证线程安全和延迟加载。

/**
 * 单例模式 - 静态内部类
 * 优点：线程安全、懒加载、性能好
 */
public class Singleton4 {
    // 1. 私有静态内部类，内部创建静态实例
    private static class SingletonInstance {
        private static final Singleton4 INSTANCE = new Singleton4();
    }
    // 2. 构造器私有
    private Singleton4() {};
    // 3. 静态公有方法，获取实例
    public static Singleton4 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

5.枚举

借助了 JDK1.5 中添加的枚举来实现单例模式

/**
 * 单例模式 - 枚举
 * 优点：线程安全、性能好、防止反序列化重新创建新的对象
 */
enum Singleton5 {
    INSTANCE; // 属性
}

单例模式的优点

1. 提供了对唯一实例的控制，确保只有一个实例存在。
2. 提供了全局访问点，方便其他类使用该实例。
3. 避免了重复创建实例的开销，提高了性能。

单例模式的应用场景

1. 数据库连接池：保证只有一个连接池实例，避免资源浪费。
2. 配置文件管理器：保证只有一个实例读取和管理配置文件。
3. 日志记录器：保证只有一个实例记录日志。

单例模式的注意事项

1. 线程安全：在多线程环境下，需要考虑线程安全性，可以使用同步锁或者双重检查锁定来保证线程安全。
2. 序列化和反序列化：如果单例类需要支持序列化和反序列化，需要添加readResolve()方法来返回单例实例。
3. 类加载器：在使用单例模式时，需要注意类加载器的问题，确保只有一个类加载器加载单例类。

总结

单例模式是一种常用的设计模式，它可以确保一个类只有一个实例，并提供一个全局访问点。通过选择合适的实现方式，可以满足不同的需求。在使用单例模式时，需要注意线程安全性、序列化和反序列化、类加载器等问题。合理地使用单例模式可以提高性能，减少资源消耗，提高代码的可维护性和可扩展性。