JAVA设计模式1：单例模式，确保每个类只能有一个实例

作者主页：Designer 小郑
作者简介：3年JAVA全栈开发经验，专注JAVA技术、系统定制、远程指导，致力于企业数字化转型，CSDN学院、蓝桥云课认证讲师。
主打方向：Vue、SpringBoot、微信小程序

本文讲解了 Java 设计模式中的单例模式，并给出了样例代码，单例模式，确保每个类只能有一个实例，并提供一个全局访问点来获取该实例。

---

一、单例模式是什么

Java 中的单例模式是一种设计模式，它确保某个类只能有一个实例，并提供一个全局访问点来获取该实例。

实现单例模式可以有多种方式，其中最常用的方式有两种：懒汉式和饿汉式。

1.1 懒汉式单例模式

懒汉式在首次调用获取实例的方法时才创建对象。

以下是一种常见的懒汉式单例模式的实现方式，请同学们认真学习。

   public class Singleton {
       private static Singleton instance;
   
       private Singleton() {
           // 私有构造方法
       }
   
       public static synchronized Singleton getInstance() {
           if (instance == null) {
               instance = new Singleton();
           }
           return instance;
       }
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

提示：上述实现在多线程环境下可以正常工作，但是由于在获取实例的方法上加了同步锁，会导致性能下降。

1.2 饿汉式单例模式

饿汉式在类加载时就创建对象，因此可以保证在任何时候都只有一个实例。

以下是一种常见的饿汉式单例模式的实现方式，请同学们认真学习。

   public class Singleton {
       private static final Singleton instance = new Singleton();
   
       private Singleton() {
           // 私有构造方法
       }
   
       public static Singleton getInstance() {
           return instance;
       }
   }
1
2
3
4
5
6
7
8
9
10
11

提示：饿汉式可以确保在多线程环境下也能正常工作，但可能会造成资源浪费，因为实例在类加载时就创建。

1.3 懒汉/饿汉单例小结

无论使用懒汉式还是饿汉式，单例模式都需要注意线程安全性、序列化和反射等方面的问题。如果需要更好的线程安全性和更高的性能，可以考虑使用双重检查锁定或静态内部类等方式实现单例模式。

---

二、单例模式有哪些

在第一章简单介绍了单例模式，接下来进行详细介绍，并给出详细代码。

在 Java 中，实现单例模式的方式有以下几种。

2.1 懒汉式（Lazy Initialization）单例模式

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造方法
    }

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.2 饿汉式（Eager Initialization）单例模式

public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {
        // 私有构造方法
    }

    public static EagerSingleton getInstance() {
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11

2.3 双重检查锁定（Double-Checked Locking）单例模式

public class DoubleCheckedSingleton {
    private volatile static DoubleCheckedSingleton instance;

    private DoubleCheckedSingleton() {
        // 私有构造方法
    }

    public static DoubleCheckedSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedSingleton();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.4 静态内部类（Static Inner Class）单例模式

public class StaticInnerSingleton {
    private StaticInnerSingleton() {
        // 私有构造方法
    }

    private static class SingletonHolder {
        private static final StaticInnerSingleton instance = new StaticInnerSingleton();
    }

    public static StaticInnerSingleton getInstance() {
        return SingletonHolder.instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

以上是常用的几种单例模式的实现方式，在实现单例模式时，需要考虑线程安全性、序列化和反射等方面的问题。

---

三、单例模式的应用场景

单例模式在以下 $5$ 情况下常常被使用，请同学们认真学习。

1. 资源共享：当多个对象需要共享同一个资源时，使用单例模式可以确保只有一个实例被创建，从而避免资源的重复创建与浪费。
2. 配置信息：单例模式可以用于管理全局的配置信息，保证配置信息的一致性和唯一性。
3. 日志记录器：在日志记录器的场景下，单例模式可以确保只有一个日志记录器实例，方便统一管理和记录日志。
4. 数据库连接池：在数据库连接池的实现中，使用单例模式可以确保只有一个连接池被创建，从而避免连接资源的滥用和浪费。
5. 线程池：在多线程场景下，使用单例模式可以确保只有一个线程池实例，方便管理和控制线程资源。

总的来说，单例模式适用于需要在系统中全局访问且只有一个实例的场景，可以提供一种简洁、方便、安全的解决方案。然而，过度使用单例模式可能导致代码的耦合性增加，应谨慎使用。

---

四、单例模式面试题

1. 请解释什么是单例模式，它的作用是什么？
2. 请列举几种常见的单例模式的实现方式，并分别说明它们的优缺点。
3. 如何确保在多线程环境下单例模式的正确工作？
4. 单例模式是否能被继承和被克隆？
5. 如何防止通过反射来破坏单例模式的实现？
6. 单例模式是否有线程安全问题？如果有，如何解决？
7. 饿汉式和懒汉式单例模式的区别是什么？在什么情况下使用哪种方式？
8. 单例模式适用于哪些场景？请举例说明。
9. 单例模式的优点和缺点分别是什么？
10. 除了单例模式，还有哪些相关的设计模式？

---

五、总结

本文讲解了 Java 设计模式中的单例模式，并给出了样例代码，在下一篇博客中，将讲解 Java 工厂方法模式。