最全面的单例模式讲解

比眉伴天荒 2023-06-27 05:30 13阅读 0赞

作为一名程序员，或许谁都能说出一种或几种设计模式，其中单利模式是最常见、最简单的一种设计模式，但是我们或许对单例模式的了解不一定全面。今天我们就探讨下单例模式。

**【单例模式的定义】**

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

**【单例模式的三个基本要点】 **

一是这个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

**【单例模式分类】**

单例模式分为饿汉式和懒汉式。

// 饿汉模式
    public final class Singleton {
        private static Singleton instance=new Singleton();// 自行创建实例
        private Singleton(){}// 构造函数
        public static Singleton getInstance(){// 通过该函数向整个系统提供实例
            return instance;
        }
    }

** 饿汉式通过static修饰成员变量instance，该变量会在类初始化的过程中被收集进类构造器的clinit方法中，在多线程场景下，JVM会保证只有一个线程执行该clinit方法。等到唯一的一次clinit方法执行完成，其他线程将不会再执行该clinit方法，也就是说，static修饰的成员变量instance，在多线程环境下只实例化一次，从而保证了该对象只有一个实例。**

饿汉式单例模式有一个缺点，在类初始化阶段就创建好了对象，如果一个框架的类都采用这种方式，那么在类初始化阶段就把所有类都创建了一个对象，而一些类我们是不常用的，那么这些不常用的类也被实例化了，这样只是白白的浪费内存。饿汉式虽然高效，但是浪费内存。

// 懒汉模式
    public final class Singleton {
        private static Singleton instance= null;// 不实例化
        private Singleton(){}// 构造函数
        public static Singleton getInstance(){// 通过该函数向整个系统提供实例
            if(null == instance){// 当 instance 为 null 时，则实例化对象，否则直接返回对象
                instance = new Singleton();// 实例化对象
            }
            return instance;// 返回已存在的对象
        }
    }

懒汉式单例模式是为了避免直接在加载类时就创建对象，采用懒加载的方式，只有当系统使用到类对象时，才会创建对象。这种方式在单线程是没有问题，但是在多线程环境下，就会出现实例化多个对象的情况。

当线程A执行到if判断还没有创建对象时，A线程cpu时间片用完了，这时B线程也执行到If判断，发现还没有对象，就new一个对象出来，这时A线程又有执行权，继续执行下面代码，就会也new一个对象。这种情况下，就会创建多个实例。

**【懒汉式单例模式逐步升级】**

通过上面分析，这种懒汉式在多线程环境下可能会创建多个实例。那我们采用加同步锁synchronized的方式，保证多线程情况下仅创建一个实例。

// 懒汉模式 + synchronized 同步锁
    public final class Singleton {
        private static Singleton instance= null;// 不实例化
        private Singleton(){}// 构造函数
        public static synchronized Singleton getInstance(){// 加同步锁，通过该函数向整个系统提供实例
            if(null == instance){// 当 instance 为 null 时，则实例化对象，否则直接返回对象
                instance = new Singleton();// 实例化对象
            }
            return instance;// 返回已存在的对象
        }
    }

我们知道，同步锁会增加锁竞争，带来系统性能开销，从而导致系统性能下降，因此这种方式也会降低单例模式的性能。  
还有，每次请求获取类对象时，都会通过 getInstance() 方法获取，除了第一次为 null，其它每次请求基本都是不为 null 的。在没有加同步锁之前，是因为 if 判断条件为 null 时，才导致创建了多个实例。基于以上两点，我们可以考虑将同步锁放在 if 条件里面，这样就可以减少同步锁资源竞争。所以我们进一步优化代码如下：

// 懒汉模式 + synchronized 同步锁
    public final class Singleton {
        private static Singleton instance= null;// 不实例化
        private Singleton(){}// 构造函数
        public static Singleton getInstance(){// 加同步锁，通过该函数向整个系统提供实例
            if(null == instance){// 当 instance 为 null 时，则实例化对象，否则直接返回对象
              synchronized (Singleton.class){
                  instance = new Singleton();// 实例化对象
              } 
            }
            return instance;// 返回已存在的对象
        }
    }

看到这里，你是不是觉得这样就可以了呢？答案是依然会创建多个实例。这是因为当多个线程进入到 if 判断条件里，虽然有同步锁，但是进入到判断条件里面的线程依然会依次获取到锁创建对象，然后再释放同步锁。所以我们还需要在同步锁里面再加一个判断条件，进一步优化代码如下：

// 懒汉模式 + synchronized 同步锁 + double-check
    public final class Singleton {
        private static Singleton instance= null;// 不实例化
        private Singleton(){}// 构造函数
        public static Singleton getInstance(){// 加同步锁，通过该函数向整个系统提供实例
            if(null == instance){// 第一次判断，当 instance 为 null 时，则实例化对象，否则直接返回对象
              synchronized (Singleton.class){// 同步锁
                 if(null == instance){// 第二次判断
                    instance = new Singleton();// 实例化对象
                 }
              } 
            }
            return instance;// 返回已存在的对象
        }
    }

以上这种方式，通常被称为 Double-Check，它可以大大提高支持多线程的懒汉模式的运行性能。那这样做是不是就能保证万无一失了呢？还会有什么问题吗？  
      其实这里又跟 Happens-Before 规则和重排序扯上关系了，这里我们先来简单了解下 Happens-Before 规则和重排序。  
JVM编译器为了尽可能地减少寄存器的读取、存储次数，会充分复用寄存器的存储值，比如以下代码，如果没有进行重排序优化，正常的执行顺序是步骤 1/2/3，而在编译期间进行了重排序优化之后，执行的步骤有可能就变成了步骤 1/3/2，这样就能减少一次寄存器的存取次数。  
int a = 1;// 步骤 1：加载 a 变量的内存地址到寄存器中，加载 1 到寄存器中，CPU 通过 mov 指令把 1 写入到寄存器指定的内存中  
int b = 2;// 步骤 2 加载 b 变量的内存地址到寄存器中，加载 2 到寄存器中，CPU 通过 mov 指令把 2 写入到寄存器指定的内存中  
a = a + 1;// 步骤 3 重新加载 a 变量的内存地址到寄存器中，加载 1 到寄存器中，CPU 通过 mov 指令把 1 写入到寄存器指定的内存中  
         在  JMM  中，重排序是十分重要的一环，特别是在并发编程中。如果 JVM 可以对它们进行任意排序以提高程序性能，也可能会给并发编程带来一系列的问题。例如，我上面讲到的 Double-Check 的单例问题，假设类中有其它的属性也需要实例化，这个时候，除了要实例化单例类本身，还需要对其它属性也进行实例化：

// 懒汉模式 + synchronized 同步锁 + double-check
    public final class Singleton {
        private static Singleton instance= null;// 不实例化
        public List<String> list = null;//list 属性
        private Singleton(){
          list = new ArrayList<String>();
        }// 构造函数
        public static Singleton getInstance(){// 加同步锁，通过该函数向整个系统提供实例
            if(null == instance){// 第一次判断，当 instance 为 null 时，则实例化对象，否则直接返回对象
              synchronized (Singleton.class){// 同步锁
                 if(null == instance){// 第二次判断
                    instance = new Singleton();// 实例化对象
                 }
              } 
            }
            return instance;// 返回已存在的对象
        }
    }

在执行 instance = new Singleton(); 代码时，正常情况下，实例过程这样的：  
        1、给 Singleton 分配内存；  
        2、调用 Singleton 的构造函数来初始化成员变量；  
        3、将 Singleton 对象指向分配的内存空间（执行完这步 singleton 就为非 null 了）。  
    如果虚拟机发生了重排序优化，这个时候步骤 3 可能发生在步骤 2 之前。如果初始化线程刚好完成步骤 3，而步骤 2 没有进行时，则刚好有另一个线程到了第一次判断，这个时候判断为非 null，并返回对象使用，这个时候实际没有完成其它属性的构造，因此使用这个属性就很可能会导致异常。在这里，Synchronized 只能保证可见性、原子性，无法保证执行的顺序。

这个时候，就体现出 Happens-Before 规则的重要性了。通过字面意思，你可能会误以为是前一个操作发生在后一个操作之前。然而真正的意思是，前一个操作的结果可以被后续的操作获取。这条规则规范了编译器对程序的重排序优化。  
        我们知道 volatile 关键字可以保证线程间变量的可见性，简单地说就是当线程 A 对变量 X 进行修改后，在线程 A 后面执行的其它线程就能看到变量 X 的变动。除此之外，volatile 在 JDK1.5 之后还有一个作用就是阻止局部重排序的发生，也就是说，volatile 变量的操作指令都不会被重排序。所以使用 volatile 修饰 instance 之后，Double-Check 懒汉单例模式就万无一失了。

** 第一种真正懒汉式单例模式代码如下：**

/**
     * 单例模式--懒汉式:synchronized + double-check + volatile
     * @author: lsl
     * @date: 2020/1/3
     */
    public class Singlnton {
        private volatile static Singlnton instance = null;
        private List<String> list = null;
        
        private Singlnton(){
            list = new ArrayList<>();
        }
        
        public  static Singlnton getSinglnton(){
            if (null == instance){
                synchronized(Singlnton.class){
                    if (null == instance){
                        instance = new Singlnton();
                    }
                }
            }
            return instance;
        }
    }

这种方式实现的懒汉式单例模式虽然保证了只创建一个对象实例，但是由于加了synchronized同步锁，性能会有一定降低，另外代码实现也必将复杂。那么有没有其他方式实现懒汉式单例模式呢？答案是肯定有的，采用内部类来实现单例。代码如下：

/**
     * 单例模式 - 懒汉式 ： 内部类实现
     * @author: lsl
     * @date: 2020/1/3
     */
    public class Singlnton {
        private Singlnton(){}
    
        public static class InnerSingleton{
            private static Singlnton instance = new Singlnton();
        }
    
        public static Singlnton getInstance(){
            return InnerSingleton.instance;
        }
    }

除了内部类的形式实现懒汉式单例模式，还可以通过枚举实现懒汉式单例模式。代码如下：

public class SinletonExample5 {
        private static SinletonExample5 instance = null;
    
        // 私有构造函数
        private SinletonExample5(){
        }
    
        public static SinletonExample5 getInstance(){
            return Sinleton.SINLETON.getInstance();
        }
    
        private enum Sinleton{
            SINLETON;
    
            private SinletonExample5 singleton;
    
            // JVM保证这个方法只调用一次
            Sinleton(){
                singleton = new SinletonExample5();
            }
    
            public SinletonExample5 getInstance(){
                return singleton;
            }
        }
    }