【设计模式】Java设计模式 – 单例模式

【设计模式】Java设计模式 - 单例模式

😄 不断学习才是王道
🔥 继续踏上学习之路，学之分享笔记
👊 总有一天我也能像各位大佬一样
🌝分享学习心得，欢迎指正，大家一起学习成长！
原创作品，更多关注我CSDN: 一个有梦有戏的人
准备将博客园、CSDN一起记录分享自己的学习心得！！！

目录

• 【设计模式】Java设计模式 - 单例模式
  • 简介
  • 1、饿汉式
    • ①、饿汉静态变量
    • ②、饿汉静态代码块
  • 2、懒汉式
    • ①、线程不安全
    • ②、线程安全
  • 3、双检锁/双重校验锁（DCL，即 double-checked locking）
  • 4、静态内部类
  • 5、枚举

简介

单例模式，是java设计模式中最简单的设计模式，是属于创建类型模式。单例模式就是只能有一个实例，即一个类有且仅有一个实例，并且自行实例化向整个系统提供。

单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。 -- （美）钟冠贤．Objective-C编程之道 iOS设计模式解析．北京市：人民邮电出版社，2011

UML图：

以下使用多线程测试的代码（如以下例子）：

class Threads extends Thread {     @Override     public void run() {         StaticVariableStarve instance = StaticVariableStarve.getInstance();         System.out.println("StaticVariableStarve hashCode: " + instance.hashCode());     } } 

在main方法中调用start。

for (int i = 0; i < 5; i++) {     new Threads().start(); } 

1、饿汉式

①、饿汉静态变量

饿汉静态变量通过创建静态变量去实例化对象，在通过静态方法返回实例，其中需要实现私有化构造方法，使得外部不能通过new直接实例化对象。
代码如下：

package com.lyd.demo.singleton;  /**  * @Author: lyd  * @Description: 单例模式 - 饿汉静态变量  * @Date: 2022-08-24  */ public class StaticVariableStarve {     // 私有化构造方法     private StaticVariableStarve() {     }     // 创建静态变量实例化     private final static StaticVariableStarve singleton = new StaticVariableStarve();     // 返回对象     public static StaticVariableStarve getInstance() {         return singleton;     } } 

饿汉静态变量的测试

单例模式创建只能有一个实例，不管是用几个变量，最后他们都是同一个实例，如下测试，通过“==”判断对象实例是否一致，打印其hashcode可以发现是一样的。

// 饿汉静态变量 StaticVariableStarve singleton1 = StaticVariableStarve.getInstance(); StaticVariableStarve singleton2 = StaticVariableStarve.getInstance(); System.out.println("两者是否相同？" + (singleton1 == singleton2)); System.out.println("singleton1的hashcode：" + (singleton1.hashCode())); System.out.println("singleton2的hashcode：" + (singleton2.hashCode())); 

运行结果：

多线程：

这样写在类装载的时候就已经实例化了，避免了线程安全问题。但是，一开始就已经实例化了，没有使用lazy loading，就会导致有时候这个实例不需要使用，但是他仍然实例化了，这样就造成了内存浪费。

②、饿汉静态代码块

静态代码块中实例化对象，通过类主动去实例化对象，当调用到这个类的时候，静态代码块的代码就会运行，从而实例化对象。
代码如下：

package com.lyd.demo.singleton;  /**  * @Author: lyd  * @Description: 饿汉静态代码块  * @Date: 2022-08-24  */ public class StaticBlockStarve {     // 私有化构造方法     private StaticBlockStarve() {     }     // 构建静态变量     private static StaticBlockStarve singleton;     static {         singleton = new StaticBlockStarve();     }     // 返回对象     public static StaticBlockStarve getInstance() {         return singleton;     } } 

饿汉静态代码块测试

// 饿汉静态代码块 StaticBlockStarve singleton3 = StaticBlockStarve.getInstance(); StaticBlockStarve singleton4 = StaticBlockStarve.getInstance(); System.out.println("两者是否相同？" + (singleton3 == singleton4)); System.out.println("singleton1的hashcode：" + (singleton3.hashCode())); System.out.println("singleton2的hashcode：" + (singleton4.hashCode())); 

运行结果:

多线程：

2、懒汉式

①、线程不安全

通过 Lazy 初始化，但是线程不安全，这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。
代码如下：

通过getInstance()获取实例，在方法内进行判断是否为空，不为空直接返回对象实例。

package com.lyd.demo.singleton;  /**  * @Author: lyd  * @Description: 懒汉式-线程不安全  * @Date: 2022-08-24  */ public class NotSafeThreadLazy {     // 私有变两个     private static NotSafeThreadLazy singleton;     // 私有构造     private NotSafeThreadLazy() {     }     // 通过方法实例化     public static NotSafeThreadLazy getInstance() {         if (singleton == null) {             singleton = new NotSafeThreadLazy();         }         return singleton;     } }  

测试

// 懒汉线程不安全 NotSafeThreadLazy singleton1 = NotSafeThreadLazy.getInstance(); NotSafeThreadLazy singleton2 = NotSafeThreadLazy.getInstance(); System.out.println("两者是否相同？" + (singleton1 == singleton2)); System.out.println("singleton1的hashcode：" + (singleton1.hashCode())); System.out.println("singleton2的hashcode：" + (singleton2.hashCode())); 

运行结果

多线程：可见生成了多个实例

用到了lazy loading，但只能在单线程下使用。但是在多线程中，可能会导致一个线程已经到达了if判空，但是还没有进行实例化，第二个线程就已经进入判空，并且也进入实例化。这样就会破坏了单例模式，两个实例化就不是同一个，因此这种方式是线程不安全，不推荐使用。

②、线程安全

这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
代码如下：

通过lazy loading实例化对象，只在第一次运行实例化，在getInstance方法中使用synchronized保证线程安全。

package com.lyd.demo.singleton;  /**  * @Author: lyd  * @Description: 懒汉式-线程安全  * @Date: 2022-08-24  */ public class SafeThreadLazy {     // 私有变两个     private static SafeThreadLazy singleton;     // 私有构造     private SafeThreadLazy() {     }     // 通过方法实例化     public static synchronized SafeThreadLazy getInstance() {         if (singleton == null) {             singleton = new SafeThreadLazy();         }         return singleton;     } } 

多线程 ：

3、双检锁/双重校验锁（DCL，即 double-checked locking）

采用双锁机制，安全且在多线程情况下能保持高性能。

在变量加上关键字volatile，在实例化的时候用synchronized线程锁，可以使线程安全。
volatile：是Java虚拟机提供的轻量级的同步机制，当某线程更新变量后，其他线程也能感知到。

• 关于volatile详情可以看 稀土掘金 https://juejin.cn/post/6861885337568804871
• 关于使用了synchronized为什么还要volatile？以及指令重排等的疑惑请看 CSDNhttps://blog.csdn.net/zengfanwei1990/article/details/110245035

package com.lyd.demo.singleton;  /**  * @Author: lyd  * @Description: 双检锁/双重校验锁  * @Date: 2022-08-24  */ public class DoubleCheckedLocking {     // 私有变两个     private static volatile DoubleCheckedLocking singleton;     // 私有构造     private DoubleCheckedLocking() {     }     // 通过方法实例化     public static DoubleCheckedLocking getInstance() {         if (singleton == null) { // [1]             synchronized (DoubleCheckedLocking.class) { // [2]                 if (singleton == null) {                     singleton = new DoubleCheckedLocking();                 }             }         }         return singleton;     } } 

在getInstance()方法中，哪怕是多线程，都能保证线程安全以及单例模式。假如有多个线程，一个线程先到达了[1]判空成功后进入实例化，此时synchronized线程锁就会上锁，在还没实例化后，然而其他线程也过来了，他们也通过了[1]判空，但是在[2]处会被拦住，直到前一个实例化结束后才解锁，等到解锁后，也就已经实例化完成，singleton就已经不再是null。

多线程：

4、静态内部类

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
代码如下：

通过SingletonHolder这个静态内部类实例化，采用类装载的方式进行实例化，但是一开始是不会实例化的，只有显式调用了getInstance()，使得SingletonHolder类被主动调用，从而实例化对象。

package com.lyd.demo.singleton;  /**  * @Author: lyd  * @Description: 静态内部类  * @Date: 2022-08-24  */ public class StaticInnerClass {     private StaticInnerClass() {}     // 静态内部类     public static class SingletonHolder {         private static final StaticInnerClass SINGLETON = new StaticInnerClass();     }     // 调用方法     public static StaticInnerClass getInstance() {         return SingletonHolder.SINGLETON;     } } 

采用了类装载的方式使实例化只有一个线程。在一开始StaticInnerClass被装载的时候，对象不一定被实例化。需要调用了getInstace()的方法，才会使得SingletonHolder被主动使用，装载SingletonHolder类，也就接着进行实例化对象。

多线程：

5、枚举

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。
代码如下：

package com.lyd.demo.singleton;  /**  * @Author: lyd  * @Description:  * @Date: 2022-08-24  */ public enum Enumeration {     INSTANCE;     public void instanceMethod() {         System.out.println("实例的方法");     } } 

测试

// 枚举 Enumeration instance = Enumeration.INSTANCE; Enumeration instance2 = Enumeration.INSTANCE; System.out.println("两者是否相同？" + (instance == instance2)); System.out.println("instance的hashcode：" + (instance.hashCode())); System.out.println("instance2的hashcode：" + (instance2.hashCode())); instance.instanceMethod(); 

结果

多线程测试：

可发现多线程下枚举也是能够实现单例模式。

👍创作不易，如有错误请指正，感谢观看！记得一键三连哦！👍

💓德德小建议：

理解设计模式不是一件简单的事情，需要不断的学习和动手去练习，才能理解。只有掌握好设计模式，才能够真正的理解SpringAOP和Mybatis的底层原理。各位读者可以和我一样，动手敲一敲代码，甚至用不同的例子来做，通过debug一步一步调试，还有就是多看看别人的例子。能够有助于理解！谢谢各位观看指点！❤️ ❤️ ❤️