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

刺骨的言语ヽ痛彻心扉 2023-10-14 09:06 14阅读 0赞

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

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

![在这里插入图片描述][e765a2d1fc1649d193897c88c493aace.png_pic_center]

#### 目录 ####

*  一、单例模式是什么
 *   *  1.1 懒汉式单例模式
     *  1.2 饿汉式单例模式
     *  1.3 懒汉/饿汉单例小结
 *  二、单例模式有哪些
 *   *  2.1 懒汉式（Lazy Initialization）单例模式
     *  2.2 饿汉式（Eager Initialization）单例模式
     *  2.3 双重检查锁定（Double-Checked Locking）单例模式
     *  2.4 静态内部类（Static Inner Class）单例模式
 *  三、单例模式的应用场景
 *  四、单例模式面试题
 *  五、总结

--------------------

## 一、单例模式是什么 ##

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 饿汉式单例模式 ###

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

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

public class Singleton {
        
           private static final Singleton instance = new Singleton();
       
           private Singleton() {
        
               // 私有构造方法
           }
       
           public static Singleton getInstance() {
        
               return instance;
           }
       }

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

### 1.3 懒汉/饿汉单例小结 ###

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

![在这里插入图片描述][d872b4b2d2634f51ac65936096f890e4.png_pic_center]

--------------------

## 二、单例模式有哪些 ##

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

在 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;
        }
    }

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

public class EagerSingleton {
        
        private static final EagerSingleton instance = new EagerSingleton();
    
        private EagerSingleton() {
        
            // 私有构造方法
        }
    
        public static EagerSingleton getInstance() {
        
            return instance;
        }
    }

### 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;
        }
    }

### 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;
        }
    }

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

![在这里插入图片描述][bd42dde0263e42e8ba918433f53f9913.png_pic_center]

--------------------

## 三、单例模式的应用场景 ##

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

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

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

![在这里插入图片描述][3632cde84c544ae48e761f8c25fb64b0.png_pic_center]

--------------------

## 四、单例模式面试题 ##

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

--------------------

## 五、总结 ##

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

![在这里插入图片描述][3a01dc60e62c415b812015851343f1c0.png_pic_center]

[Designer]: https://blog.csdn.net/qq_41464123
[e765a2d1fc1649d193897c88c493aace.png_pic_center]: https://img-blog.csdnimg.cn/e765a2d1fc1649d193897c88c493aace.png#pic_center
[d872b4b2d2634f51ac65936096f890e4.png_pic_center]: https://img-blog.csdnimg.cn/d872b4b2d2634f51ac65936096f890e4.png#pic_center
[bd42dde0263e42e8ba918433f53f9913.png_pic_center]: https://img-blog.csdnimg.cn/bd42dde0263e42e8ba918433f53f9913.png#pic_center
[3632cde84c544ae48e761f8c25fb64b0.png_pic_center]: https://img-blog.csdnimg.cn/3632cde84c544ae48e761f8c25fb64b0.png#pic_center
[3a01dc60e62c415b812015851343f1c0.png_pic_center]: https://img-blog.csdnimg.cn/3a01dc60e62c415b812015851343f1c0.png#pic_center