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) {//抢到锁之后再次判断是否为nullif(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) {//抢到锁之后再次判断是否为nullif(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的时候才会出现线程安全问题，一旦初始化完成就不存在了。