Java学习笔记整理: 关于设计模式:单例模式 2024/7/10；

单例模式

自理解:该模式下的类有且仅能拥有一个类对象的类，外界必须通过静态方法先获取到该对象才能使用其类内的方法;

创建型模式:

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一,它提供了一种创建对象的最佳方式;这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式的主要有以下角色：

• 单例类。只能创建一个实例的类.

• 访问类。使用单例类;

单例模式的实现,单例设计模式分类两种:

饿汉式：类加载就会导致该单实例对象被创建

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

1. 饿汉式-方式1（静态变量方式）

   /**
    * 饿汉式
    *      静态变量创建类的对象
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance = new Singleton();
   ​
       //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           return instance;
       }
   }
    * 饿汉式
    *      静态变量创建类的对象
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance = new Singleton();
   ​
       //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           return instance;
       }
   }

   说明：

   该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

1. 懒汉式（双重检查锁）*

   再来讨论一下懒汉模式中加锁的问题，对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式

   /**
    * 双重检查方式
    */
   public class Singleton { 
   ​
       //私有构造方法
       private Singleton() {}
           //volatile关键词把修改的值同步到主内存中,并使线程读取必须到主内存读
       private static volatile Singleton instance;
   ​
      //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
           if(instance == null) {
               synchronized (Singleton.class) {
                   //抢到锁之后再次判断是否为null
                   if(instance == null) {
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   }
    * 双重检查方式
    */
   public class Singleton { 
   ​
       //私有构造方法
       private Singleton() {}
           //volatile关键词把修改的值同步到主内存中,并使线程读取必须到主内存读
       private static volatile Singleton instance;
   ​
      //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
           if(instance == null) {
               synchronized (Singleton.class) {
                   //抢到锁之后再次判断是否为null
                   if(instance == null) {
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   }

   双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

   要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

   底层原理:

   线程调用主内存中获取变量,并设置备份进行使用;多个线程共享这个备份;但主内存中关闭之后,线程中的备份并不会改变;会继续执行;

   所以需要使用volatile关键词修饰变量;使该变量同步主内存中的值,并且使线程读取该变量必须到主内存中进行读取;

   双层判断+锁是为了解决线程安全和性能;

   new对象只有一次,如果使用锁方法每次都加锁将大大降低性能;

   所以使用if判断来判断是否加锁能显著提高性能;双层判断是防止二次new对象;

1. 懒汉式-方式1（线程不安全）

   /**
    * 懒汉式
    *  线程不安全
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance;
   ​
       //对外提供静态方法获取该对象
       public static Singleton getInstance() {
   ​
           if(instance == null) {
               instance = new Singleton();
           }
           return instance;
       }
   }
    * 懒汉式
    *  线程不安全
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance;
   ​
       //对外提供静态方法获取该对象
       public static Singleton getInstance() {
   ​
           if(instance == null) {
               instance = new Singleton();
           }
           return instance;
       }
   }

   说明：

   从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。

1. 懒汉式-方式2（线程安全）

   /**
    * 懒汉式
    *  线程安全
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance;
   ​
       //对外提供静态方法获取该对象
       public static synchronized Singleton getInstance() {
   ​
           if(instance == null) {
               instance = new Singleton();
           }
           return instance;
       }
   }
    * 懒汉式
    *  线程安全
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance;
   ​
       //对外提供静态方法获取该对象
       public static synchronized Singleton getInstance() {
   ​
           if(instance == null) {
               instance = new Singleton();
           }
           return instance;
       }
   }

   说明：

   该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。