＜JavaEE＞ 单例模式的两种实现：“饿汉模式”和“懒汉模式”

目录

一、单例模式概述

二、“饿汉模式”实现单例模式

三、“懒汉模式”实现单例模式

3.1 单线程下的“懒汉模式”

3.2 多线程下的“懒汉模式”

---

一、单例模式概述

1）什么是单例模式？

单例模式是一种设计模式。 单例模式可以保证某个类在程序中只存在唯一实例，即不允许创建多份实例。 使用单例模式，上述要求就得到了检查和校验。

2）单例模式的实现形式

单例模式可以通过很多种方法实现，“饿汉模式”和“懒汉模式”是其中最基础的两种，本文只介绍这两种实现。

二、“饿汉模式”实现单例模式

通过代码演示“饿汉模式”实现的单例模式：

class Singleton{
    //新建一个唯一实例；
    private static Singleton instance = new Singleton();

    //方法返回唯一实例；
    public static Singleton getInstance() {
        return instance;
    }

    //将构造方法私有化；
    private Singleton() { }
}

1）上述代码做了什么？

创建了一个被 static 修饰的实例，这个实例成为了类属性。类对象只会有一个，这个类属性也只会有一个。

私有化构造方法，外部无法 new 新的实例，只能通过 get 方法获取唯一的那一个 instance。

2）为什么叫做“饿汉模式”？

上述代码中，实例是类属性。类属性在类加载的时候就创建了，创建时机早，十分“迫切”，因此称为“饿汉模式”。

代码证明“饿汉模式”返回的实例是唯一的：

public class Singleton_Demo0 {
    public static void main(String[] args) {
        //想直接new对象，就会报错；
        //Singleton instance = new Singleton();
        
        //两次调用getInstance()方法并分别赋值；
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        //对比两个变量，发现是同一实例；
        if(instance1 == instance2){
            System.out.println("两个对象是同一个对象");
        }
    }
}

//运行结果：
两个对象是同一个实例

3）“饿汉模式”的单例模式在多线程下是线程安全的吗？

上述代码中，get 方法返回的是已经创建好的实例，这个操作本质上只是一个“读操作”，多个线程读取同一个变量并不会造成线程不安全。 因此“饿汉模式”的单例模式在多线程下是线程安全的。

三、“懒汉模式”实现单例模式

3.1 单线程下的“懒汉模式”

通过代码演示“懒汉模式”实现的单例模式：

class Singleton{
    //声明一个变量作为类属性；
    private static Singleton instance = null;

    //判断变量是否为null，是则创建实例后返回，否则返回；
    public static Singleton getInstance() {
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }

    //将构造方法私有化；
    private Singleton() { }
}

1）上述代码做了什么？

声明了一个类属性。类对象只会有一个，这个类属性也只会有一个。

私有化构造方法，外部无法 new 新的实例，只能通过 get 方法获取唯一的那一个 instance。

get 方法中根据变量是否为 null 判断是否应该创建实例。

2）为什么叫做“懒汉模式”？

上述代码中，实例是在程序员第一次调用 get 方法后才创建的，创建时机较晚，或者根本不用创建，因此称为“懒汉模式”。

3.2 多线程下的“懒汉模式”

1）单线程下的“懒汉模式”在多线程下是线程安全的吗？

答案是否定的，单线程下的“懒汉模式”在多线程下是线程不安全的，我们可以从以下两个方面分析：

“原子性”： 上述代码中判断变量是否为空的代码 —— if(instance == null)，和实例化代码 ——  instance = new Singleton()，并非是“原子”的。在多线程环境下，这就可能导致线程不安全。 可以使用 synchronized 关键字，将这两句代码加锁，解决这个问题。

内存可见性和指令重排序： 因为 instance 是一个被 static 修饰的共享数据，而且编译器内部可能对实例化的代码 —— new Singleton()，进行了编译器优化。 这就无法保证内存的可见性和指令的顺序执行，因此在多线程环境下可能导致线程不安全。 可以使用 volatile 关键字，对共享数据 instance 进行修饰，解决这个问题。

使用以上两个关键字的原因和方式，详细请参考以下博客：

阅读指针 -> 《synchronized 关键字 和 volatile 关键字》＜JavaEE＞ synchronized关键字和锁机制 -- 锁的特点、锁的使用、锁竞争和死锁、死锁的解决方法-CSDN博客文章浏览阅读70次。介绍了 synchronized 关键字 和 锁机制，其中重点介绍了锁的特点、使用方法和死锁的相关内容。https://blog.csdn.net/zzy734437202/article/details/134742168＜JavaEE＞ volatile关键字 -- 保证内存可见性、禁止指令重排序-CSDN博客文章浏览阅读59次。简单介绍什么是内存可见性和指令重排序。volatile关键字可以将这两种编译器优化强制关闭。https://blog.csdn.net/zzy734437202/article/details/134757070

2）“懒汉模式”在多线程下应该怎么编写？

根据上述分析，根据单线程模式下的“懒汉模式”进行改进。 方法如下： 增加 volatile 关键字对共享数据进行修饰。 为判断是否为 null 和 实例化的代码加锁，使这两句代码称为“原子”。

增加 volatile 关键字对共享数据进行修饰：

private volatile static Singleton instance = null;

为判断是否为 null 和 实例化的代码加锁，使这两句代码称为“原子”：

    public static Singleton getInstance() {
        synchronized (locker){
            if(instance == null){
                instance = new Singleton();
            }
        }
        return instance;
    }

3）“双重校验锁”

我们再仔细分析一下上述的 get 方法。 假设程序需要多次调用这个 get 方法，那么每一次进入都会进行加锁，加锁是会增加系统开销的。 那么是否真的有必要每次都加锁呢？ 当 get 方法被第一次调用，实例就会被创建，那么后续再调用这个 get 方法时，返回实例就好了，加锁部分的代码块，完全可以不用执行。 在加锁的代码块之外，再增加一个if(instance == null)进行判断，那么实例在被创建之后，也就不会再进入加锁的代码块中了。 我们成功利用“双重校验锁”，优化了程序。

代码演示“双重校验锁”优化后的 get 方法：

    public static Singleton getInstance() {
        //这个if用于判断是否需要加锁；
        if(instance == null){
            synchronized (locker){
                //这个if用于判断是否需要新建实例；
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

经过以上的完善和优化，我们终于可以写出在多线程下保证线程安全的“懒汉模式”单例模式了：

class Singleton{
    //声明一个变量作为类属性；
    private volatile static Singleton instance = null;

    private static final Object locker = new Object();

    //判断变量是否为null，是则创建实例后返回，否则返回；
    public static Singleton getInstance() {
        //这个if用于判断是否需要加锁；
        if(instance == null){
            synchronized (locker){
                //这个if用于判断是否需要新建实例；
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    //将构造方法私有化；
    private Singleton() { }
}

---

阅读指针 -> 《阻塞队列》

链接生成中.........