【JavaEE】单例模式_业界新闻

发布时间:2024-07-29 13:09

阅读量:0

前言

在聊单例模式之前，我们先来了解一下什么是设计模式？

设计模式是在软件工程中用来解决常见问题的一种标准方法或模板，它们代表了软件开发者在面对特定类型的问题时，经过验证的、可复用的解决方案。设计模式并不是完成具体任务的代码，而是一种描述问题和解决方案的方式，帮助开发者理解如何设计灵活、可维护和可扩展的系统。

设计模式通常分为三大类：

创建型模式(Creational Patterns):关注于对象的创建机制，确保系统在合适的地方创建合适的对象。
结构型模式(Structural Patterns):关注的是如何组合类或对象构成更大的结构。
行为型模式(Behavioral Patterns):关注的是对象之间的职责分配和通信机制。

单例模式是在面试中常见的设计模式之一，属于创建型模式。

1.单例模式

单例模式能够保证某个类在程序中只存在唯一一份实例，而不会创建出多个实例，并通过提供一个全局访问点来访问这个实例。单例模式可以避免重复创建，减轻系统性能压力。

常见的单例模式有：1、饿汉模式；2、懒汉模式。

2.如何实现单例模式

2.1饿汉模式

饿汉模式是最简单的单例模式实现，实例在类加载时就被创建。

为什么构造方法要设置为private权限？

为了防止其他人不小new了这个对象。每次调用都需要通过getInstance方法

/**  * 单例模式的实现类。  * 保证一个类只有一个实例，并提供一个全局访问点。  */ class Singleton{     // 静态实例变量，确保在类加载时就初始化，从而实现单例。     private static Singleton singleton=new Singleton();      /**      * 公共的静态方法，用于获取Singleton类的唯一实例。      *      * @return Singleton类的唯一实例。      */     public static Singleton getInstance(){         return singleton;     }      // 将构造函数私有化，防止外部通过new方式创建实例，确保单例的唯一性。     //为了让外面的不可以创建实例，单例模式，构造方法要私有化     private Singleton(){} }  public class Singles {     public static void main(String[] args) {         // 通过getInstance方法获取Singleton的实例         Singleton s1=Singleton.getInstance();         // 再次通过getInstance方法获取Singleton的实例         Singleton s2=Singleton.getInstance();         // 检查两个实例是否相同，预期输出为true         System.out.println(s1==s2);//true     } }

运行之后，我们期望的结果是两个对象的实例是一样的。

上述的饿汉模式在创建实例时，是在类加载时就创建好了，但如果想要让其晚一点创建呢？

那么我们就得使用懒汉模式。

2.2懒汉模式

类加载的时候不创建实例，第一次使用的时候才创建实例。饿汉模式是在通过在类里创建了一个静态的实例，静态的成员变量在类加载的时候就会被创建，这样就会导致不管是否有用到这个实例，这个实例都会被创建，这样就会造成资源浪费。而懒汉模式则是通过在类中定义一个静态成员变量，并初始化为null。当调用getInstance时，如果静态成员变量为空，那么就会创建一个实例；反之，则直接返回这个实例。

class SingleLazy{     private static SingleLazy singleLazy=null;      public static SingleLazy getInstance(){         if(singleLazy==null){             singleLazy=new SingleLazy();         }         return singleLazy;     }          private SingleLazy(){} }

但如果是在多线程中，懒汉模式按照上面写真的没事吗，其实不然，若真的按照上面去实例对象，会出现线程安全问题。

3.单例模式中的线程安全问题

在上一篇中，我们已经知道了线程在操作系统中是抢占式执行、随机调度的。

对于饿汉模式，在创建对象时不会出现线程安全问题，但对于懒汉模式，会有线程安全问题。

懒汉模式的getInstance方法中，想要创建实例，是需要先通过判断再进行修改的。这种是典型的线程不安全代码，在判断和修改之间，线程可能会进行切换。

3.1加锁

对于上述这种线程安全问题，那么我们就可以进行加锁。那这把锁加在哪里？我们知道线程安全问题是出现在if和new操作上，这两操作应该打包为一个整体。

class SingleLazy{     private static SingleLazy singleLazy=null;      public static SingleLazy getInstance(){         synchronized (SingleLazy.class) {             if (singleLazy == null) {                 singleLazy = new SingleLazy();             }         }         return singleLazy;     }      private SingleLazy(){} }

虽然通过加锁，我们解决了在判断和实例之间线程安全问题，但同时，我们还需要考虑一下，如果我们已经创建了实例，那么后续调用getInstance方法还需要进行加锁操作吗？不需要，我们在此加锁，是为了将if和new合为一个整体，防止在线程在if和new之间来回切换。

当我们实例完之后，if语句是进不去的。后续操作都是读操作。若每个线程调用getInstance方法都需要加锁，就会产生阻塞，影响性能。

3.2解决懒汉模式中频繁加锁问题

针对上述问题，我们需要在加锁之前，判断一下当前的singlelazy对象是否为null，若为null，则进行加锁操作，并进行实例；反之，则直接返回singlelazy。

/**  * 单例模式的懒汉式实现，确保在多线程环境下安全地创建单例对象。  * 这种实现方式称为"双重检查锁定"，既延迟了单例的初始化，又保证了线程安全性。  */ class SingleLazy {     // 静态实例变量，初始为null，用于存储单例对象     private static SingleLazy singleLazy = null;      /**      * 静态方法，用于获取单例对象。      * 如果实例尚未创建，则通过双重检查锁定来确保线程安全地创建单例。      *       * @return 单例对象的实例      */     public static SingleLazy getInstance() {         // 检查实例是否已经存在，如果不存在则进行实例化         if (singleLazy == null) {             // 使用synchronized关键字确保线程安全             synchronized (SingleLazy.class) {                 // 再次检查实例是否存在，避免多线程环境下重复实例化                 if (singleLazy == null) {                     // 实例化单例对象                     singleLazy = new SingleLazy();                 }             }         }         // 返回单例对象         return singleLazy;     }      // 将构造函数设为私有，防止外部直接实例化对象     private SingleLazy() {} }

可能有人会疑惑，这里为什么要判断两次singlelazy是否为空？

第一次if：判断是否需要加锁
第二次if：判断是否要创建实例。

懒汉模式的代码到这，问题都解决了吗？

还没有，在new对象时，可能会造成重排序问题。重排序问题也是造成线程安全问题的因素之一。

在new一个对象时，其实可以分为三个步骤：
向内存申请空间
执行构造方法并初始化
将内存空间的地址赋值给引用变量

如果发生指令重排序，本来线程的执行顺序为1、2、3，但却被重排序为1、3、2，那么在线程并发执行时，可能就会出现问题。

从图中可以看到，线程t1判断完singlelazy为空之后，进入if分支创建实例时，此时若执行完两条指令，但此时线程被切换到t2，线程t2中singlelazy在判断完不为空，直接返回singlelazy对象，但由于此时的singlelazy并没有被初始化，若被使用，则会出现问题。

3.3解决new中指令重排序的线程安全问题

对于上述问题，这种情况就是因为编译器为了提高性能，对指令的顺序进行了优化。

示例：

假如我们现在有个清单：

买西瓜
买酱油
买哈密瓜
买葡萄

若我们按着清单的顺序来买，即是：

但是一般水果都是在店里都有，所以可以进行优化：

但是我们在某些情况下我们不想要进行优化，那么我们就可以使用volatile关键字来防止指令重排序，保证内存的可见性。

/**  * 单例模式的懒汉式实现，确保在多线程环境下安全地创建单例对象。  * 这种实现方式称为"双重检查锁定"，既延迟了单例的初始化，又保证了线程安全性。  */ class SingleLazy {     // 使用volatile修饰符确保多线程环境下的可见性，避免出现指令重排序的问题     // 静态实例变量，初始为null，用于存储单例对象      private static volatile SingleLazy singleLazy = null;      /**      * 静态方法，用于获取单例对象。      * 如果实例尚未创建，则通过双重检查锁定来确保线程安全地创建单例。      *       * @return 单例对象的实例      */     public static SingleLazy getInstance() {         // 双重检查锁定的第一重检查，如果实例已经存在，则直接返回，避免不必要的同步锁定         // 检查实例是否已经存在，如果不存在则进行实例化         if (singleLazy == null) {             // 使用synchronized关键字确保线程安全，避免多个线程同时进入创建实例的代码块             // 使用synchronized关键字确保线程安全             synchronized (SingleLazy.class) {                 // 双重检查锁定的第二重检查，再次确认实例是否已经被其他线程创建，避免重复创建实例                 // 再次检查实例是否存在，避免多线程环境下重复实例化                 if (singleLazy == null) {                     // 实例化单例对象                     singleLazy = new SingleLazy();                 }             }         }         // 返回单例对象         return singleLazy;     }      // 将构造函数设为私有，防止外部直接通过new关键字创建实例，确保单例的唯一性     // 将构造函数设为私有，防止外部直接实例化对象     private SingleLazy() {} }

所以我们在使用懒汉模式时，需要考虑三个因素：