剖析 Java 单例模式：直击痛点，探寻优化之道

2023-10-23 06:02:13

揭开 Java 单例模式的本质与痛点

单例模式的本质是确保一个类只有一个实例，其核心在于如何创建和管理这个唯一的实例。在 Java 中，实现单例模式有多种方式，最常见的有饿汉式、懒汉式和双重校验锁。

饿汉式：

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {}

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

饿汉式单例模式在类加载时就创建实例，线程安全且性能高，但缺点是无法延迟实例化，可能造成资源浪费。

懒汉式：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

懒汉式单例模式在第一次使用时才创建实例，延迟了实例化，但可能会存在线程安全问题。

双重校验锁：

public class Singleton {
    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;
    }
}

双重校验锁单例模式在第一次使用时才创建实例，并使用双重校验锁来保证线程安全，是饿汉式和懒汉式的折中方案。

然而，这些传统的单例模式实现方法都存在一定的痛点：

饿汉式： 资源浪费，可能在实例从未被使用的情况下仍然创建了实例。
懒汉式： 线程不安全，可能导致多个线程同时创建多个实例。
双重校验锁： 虽然解决了线程安全问题，但代码复杂，可读性差。

探索优化之道：打破常规，焕发新生

为了解决 Java 单例模式的痛点，我们可以探索一些优化之道，打破常规，焕发新生。

枚举实现：

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // ...
    }
}

枚举是 Java 中内置的单例模式实现方式，不仅线程安全，而且简洁优雅，但枚举类不能继承其他类，灵活性稍差。

静态内部类实现：

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

    private Singleton() {}

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

静态内部类实现单例模式可以延迟实例化，同时保证线程安全，但代码略显繁琐。

双重检查锁优化：

public class Singleton {
    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;
    }
}

双重校验锁单例模式可以通过优化代码，使其更加简洁清晰：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

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