01-单例模式

Minhat原创2026/7/11大约 10 分钟

单例模式确保一个类只有一个实例，并提供全局访问点。常见实现方式包括：饿汉式（类加载时实例化，线程安全但可能浪费内存）、懒汉式（延迟加载但需处理线程安全）、静态内部类（推荐，延迟加载且线程安全）、枚举（最简洁，防止反序列化）。优点包括节省资源、控制访问；缺点为扩展困难、职责过重。适用于只需唯一实例的场景，如序列号生成器，但应避免用于全局变量或数据库连接。

1、单例模式定义

单例模式(Singleton Pattern)确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

2、单例模式的几种实现方式

2.1、饿汉式线程安全静态常量

2.1.1、代码

/**
 * 饿汉式单例模式
 *
 * @author Minhat
 */
public class HungrySingletonPattern {
    public static void main(String[] args) {
        Singleton.getInstance().action();
    }

    public static class Singleton {
        /**
         * 静态常量
         */
        private final static Singleton INSTANCE = new Singleton();

        private Singleton() {
        }

        /**
         * 获取实例
         *
         * @return 实例
         */
        public static Singleton getInstance() {
            return INSTANCE;
        }

        /**
         * 模拟业务操作
         */
        public void action() {
            System.out.println("饿汉式单例模式");
        }
    }
}

2.1.2、优缺点说明

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化
instance 就没有达到 lazy loading 的效果
结论：这种单例模式可用，可能造成内存浪费

2.2、饿汉式线程安全静态代码块

2.2.1、代码

/**
 * 饿汉式静态代码块单例模式
 *
 * @author Minhat
 */
public class HungryStaticBlockSingletonPattern {
    public static void main(String[] args) {
        Singleton.getInstance().action();
    }

    public static class Singleton {
        /**
         * 静态常量
         */
        private static final Singleton INSTANCE;

        // 静态代码块
        static {
            INSTANCE = new Singleton();
        }

        /**
         * 获取实例
         *
         * @return 实例
         */
        public static Singleton getInstance() {
            return INSTANCE;
        }

        /**
         * 模拟业务操作
         */
        public void action() {
            System.out.println("饿汉式静态代码块单例模式");
        }
    }
}

2.2.2、优缺点说明

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
结论：这种单例模式可用，但是可能造成内存浪费

2.3、懒汉式线程不安全

2.3.1、代码

/**
 * 懒汉式线程不安全单例模式
 *
 * @author Minhat
 */
public class LazyNotSafeSingletonPattern {
    public static void main(String[] args) {
        Singleton.getInstance().action();
    }

    public static class Singleton {
        private static Singleton instance;

        private Singleton() {
        }

        /**
         * 获取实例
         *
         * @return 实例
         */
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }

        /**
         * 模拟业务操作
         */
        public void action() {
            System.out.println("懒汉式线程不安全单例模式");
        }
    }
}

2.3.2、优缺点说明

起到了Lazy Loading的效果，但是只能在单线程下使用。
如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
结论：在实际开发中，不要使用这种方式.

2.4、懒汉式线程安全

2.4.1、代码

/**
 * 懒汉式线程安全单例模式
 *
 * @author Minhat
 */
public class LazySafeSingletonPattern {
    public static void main(String[] args) {
        Singleton.getInstance().action();
    }

    public static class Singleton {
        private static Singleton instance;

        private Singleton() {
        }

        /**
         * 获取实例
         *
         * @return 实例
         */
        public static synchronized Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }

        /**
         * 模拟业务操作
         */
        public void action() {
            System.out.println("懒汉式线程安全单例模式");
        }
    }
}

2.4.2、优缺点说明

解决了线程不安全问题
效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低
结论：在实际开发中，不推荐使用这种方式

2.5、懒汉式双重检查锁定

2.5.1、代码

/**
 * 懒汉式双重检查锁单例模式
 *
 * @author Minhat
 */
public class LazyDoubleCheckSingletonPattern {
    public static void main(String[] args) {
        Singleton.getSingleton().action();
    }

    public static class Singleton {
        private volatile static Singleton singleton;

        private Singleton() {
        }

        /**
         * 获取实例
         *
         * @return 实例
         */
        public static Singleton getSingleton() {
            if (singleton == null) {
                synchronized (Singleton.class) {
                    if (singleton == null) {
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }

        /**
         * 模拟业务操作
         */
        public void action() {
            System.out.println("懒汉式双重检查锁单例模式");
        }
    }
}

2.5.1、优缺点说明

优点

懒加载，资源利用率高：实例在首次使用时才创建，避免应用启动时占用不必要的内存。
性能好，减少同步开销：相比同步方法，只在第一次创建实例时需要加锁，后续获取实例时直接走第一个 if 判断（无锁），性能损耗极小。
线程安全：volatile+ 两次null检查 + 同步块，确保多线程下单例唯一
- 第一次检查：避免不必要的加锁
- 同步块：保证只有一个线程进入创建代码。
- 第二次检查：防止在等待锁期间实例被其他线程创建。
- volatile：禁止指令重排，避免拿到"半初始化"对象。

缺点

实现复杂，容易出错：代码结构相对繁琐，需理解volatile和同步的关系。早期（JDK 1.4 前）因 JMM 缺陷，DCL 不可靠；JDK5+ 才通过volatile完整语义修复。若忘记加volatile，仍会有隐患。
不能防止反射破坏：通过反射仍可强行创建新实例
不能防止序列化破坏：反序列化会生成新对象，需添加readResolve()方法，否则单例失效。
volatile有轻微性能开销：volatile读写会禁止 CPU 缓存优化，要求直接操作主存。在极高并发下，比饿汉式或静态内部类的非volatile方案有微小差异（实际生产环境中通常可忽略）。
在 JDK 1.4 及以前不可用：老版本 JMM 中volatile无法阻止指令重排，DCL 存在拿到未初始化对象的风险。

2.6、懒汉式线程安全静态内部类

2.5.1、代码

/**
 * 懒汉式静态内部类单例模式
 *
 * @author Minhat
 */
public class LazyStaticInnerSingletonPattern {
    public static void main(String[] args) {
        Singleton.getInstance().action();
    }

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

        private Singleton() {
        }

        /**
         * 获取实例
         *
         * @return 实例
         */
        public static Singleton getInstance() {
            return SingletonHolder.INSTANCE;
        }

        /**
         * 模拟业务操作
         */
        public void action() {
            System.out.println("懒汉式静态内部类单例模式");
        }
    }
}

2.5.2、优缺点说明

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
结论：推荐使用.

2.7、饿汉式枚举单例模式

2.6.1、代码

/**
 * 饿汉式枚举单例模式
 *
 * @author Minhat
 */
public class HungryEnumSingletonPattern {
    public static void main(String[] args) {
        Singleton.INSTANCE.action();
    }

    public enum Singleton {
        /**
         * 枚举值
         */
        INSTANCE;

        /**
         * 模拟业务操作
         */
        public void action() {
            System.out.println("饿汉式枚举单例模式");
        }
    }
}

2.6.2、优缺点说明

这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
这种方式是Effective Java作者Josh Bloch 提倡的方式
结论：推荐使用

3、单例模式优缺点

3.1、单例模式优点

提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它，并为设计及开发团队提供了共享的概念。
由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例。

3.2、单例模式缺点

由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品本身的功能融合到一起。
滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；现在很多面向对象语言（如Java、C#)
的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致对象状态的丢失。

4、模式适用环境

在以下情况下可以使用单例模式。

系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器，或者需要考虑资源消耗太大而只允许创建一个对象。
客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

使用单例模式有一个必要条件：在一个系统中要求一个类只有一个实例时才应当使用单例模式。反过来，如果一个类可以有几个实例共存，就需要对单例模式进行改进，使之成为多例模式。

在使用的过程中我们还需要注意以下两个问题。

不要使用单例模式存取全局变量，因为这违背了单例模式的用意，最好将全局变量放到对应类的静态成员中。
不要将数据库连接做成单例，因为一个系统可能会与数据库有多个连接，并且在有
连接池的情况下，应当尽可能及时释放连接。单例模式由于使用静态成员存储类的实例，所以可能会造成资源无法及时释放，带来一些问题。