[面试Java]线程安全的单例模式之饿汉和懒汉实现

最新推荐文章于 2024-04-13 04:53:46 发布

梦想总是要不可及，是不是应该放弃

最新推荐文章于 2024-04-13 04:53:46 发布

阅读量718

点赞数 1

分类专栏： Java 文章标签： java 多线程单例模式高并发线程安全

本文链接：https://blog.csdn.net/ten_sory/article/details/112064549

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

导言

单例模式是最常用的一种设计模式，常用于获取公共对象的代码中。例如：

mysql数据库连接池
文件系统HDFS的连接FileSystem对象
Spark的上下文对象SparkContext
全局的计数器
全局的日志对象Logger

用户不希望创建多个对象，而是当一个对象创建之后不再创建，其他线程如果需要直接获取不需要重复创建，也希望通过这个单例对象共享数据，因此单例模式，在计算机编程中，是比较常用的一种设计模式。然而，单例模式常常出现在多线程并发的场景中，写出一个线程安全、效率高、开销小的单例模式，对初级程序员并不容易。

基于Java语言的单例模式，需要保证线程安全，实现线程安全的单例模式的方式有几种，但是效率不尽相同，因此我们需要了解和掌握写出效率最高且线程安全的单例模式。

单例模式分为两种：恶汉模式和懒汉模式，恶汉模式不存在线程安全问题，懒汉模式一般需要考虑线程安全问题。

单例模式

单例饿汉式

饿汉式，顾名思义，用餐的客人很饿，他们需要吃饭的时候，食物就需要马上摆上桌子而不能等着下单点菜之后后厨才开始做菜。这就要求餐厅一开门就得把食物准备好把菜做好，放进保温箱当中，客人一进门直接吃现成的。

饿汉式表示类加载的过程中就创建了单例对象，这个对象是类变量，即静态变量，静态变量是属于类而不是属于某一个对象的，而类只加载一次，所以饿汉式的单例模式，不存在线程安全问题。饿汉单例模式中，需要一个类变量和一个类方法，如下代码所示：

package com.java.www.day20210101;

class SingleInstanceHungry{

    // 类记载就创建对象，而且是静态变量
    private static SingleInstanceHungry instance = new SingleInstanceHungry();

    // 静态方法，用于获取上面这个静态对象
    public static SingleInstanceHungry getInstance(){
        return instance;
    }
}

public class SingleInstanceTest {

    public static void main(String[] args) {

        for (int i = 0; i < 5; i++) {
            // 多个线程去获取单例对象
            new Thread(new Runnable() {
                public void run() {
                    SingleInstanceHungry instance = SingleInstanceHungry.getInstance();
                    System.out.println(Thread.currentThread().getName()+"---"+instance);
                }
            }).start();
        }
    }
}

运行结果如下：

Thread-0---com.java.www.day20210101.SingleInstanceHungry@3d6741a8
Thread-1---com.java.www.day20210101.SingleInstanceHungry@3d6741a8
Thread-3---com.java.www.day20210101.SingleInstanceHungry@3d6741a8
Thread-4---com.java.www.day20210101.SingleInstanceHungry@3d6741a8
Thread-2---com.java.www.day20210101.SingleInstanceHungry@3d6741a8

Process finished with exit code 0

可以看出，多个线程加载的对象是同一个对象，实现了单例目的，是线程安全的，因为这个对象完完全全是共有的。

至此，最简单的单例饿汉模式完成。

单例懒汉式

饿汉式单例模式虽然容易实现，但是如果使用饿汉模式，在一些对象比较大的场景中，会拖慢程序的启动效率，因此推荐使用懒汉模式。懒汉式，顾名思义，客人很懒，从来不会提前准备，需要的时候才开始准备买菜做菜。

饿汉式中，需要一个类变量表示单例对象，需要需要一个静态方法用于获取单例对象。

代码如下所示：

package com.java.www.day20210101;

class SingleInstanceLazy{
    // 此时不创建
    private static SingleInstanceLazy instance;

    static SingleInstanceLazy getInstance(){
    	// (*)
        if (instance==null){
            // (**)
            // 如果没有创建过，现在才开始创建
            instance = new SingleInstanceLazy();
        }
        // 实例如果存在了，返回
        return instance;
    }
}

public class SingleInstanceLayTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                public void run() {
                    SingleInstanceLazy instance = SingleInstanceLazy.getInstance();
                    System.out.println(Thread.currentThread().getName()+"---"+instance);
                }
            }).start();
        }
    }
}

运行结果为：

Thread-1---com.java.www.day20210101.SingleInstanceLazy@5169ce60
Thread-7---com.java.www.day20210101.SingleInstanceLazy@5169ce60
Thread-2---com.java.www.day20210101.SingleInstanceLazy@5169ce60
Thread-6---com.java.www.day20210101.SingleInstanceLazy@35d7e55a
Thread-5---com.java.www.day20210101.SingleInstanceLazy@5169ce60
Thread-8---com.java.www.day20210101.SingleInstanceLazy@5169ce60
Thread-0---com.java.www.day20210101.SingleInstanceLazy@5bfdf791
Thread-9---com.java.www.day20210101.SingleInstanceLazy@5169ce60
Thread-3---com.java.www.day20210101.SingleInstanceLazy@5169ce60
Thread-4---com.java.www.day20210101.SingleInstanceLazy@5169ce60

Process finished with exit code 0

可以看到有明显的线程安全问题，Thread-6创建了一个新的对象，不是单例了。问题出在：线程 A进入(*)处代码，判断发现对象的引用instance为空，进入(**)处代码准备创建单例，但还没创建就阻塞了，此时线程B进入(*)处代码，判断发现instance为空，进入``(**)处代码准备创建单例，最后成功创建了单例；之后线程A被唤醒再次执行了创建单例对象的代码，此时创建了两个对象，因此破坏了单例，不是线程安全的单例模式。

一种解决办法，让getInstance()方法成为同步方法，在返回值类型前面添加一个synchronized关键字，这样多线程场景下，这个方法的执行变成了原子的，不会存在上述两个线程判断instance为空之后都创建对象的不安全情形发生。但是，这种办法有一个缺点就是效率低：无论instance是否为空，所有的线程都要获取锁，判断-创建对象以单线程的方式进行虽然可以避免对象的重复创建，但如果对象被创建成功了，之后依然要以单线程的方式获取对象，并发度为1，效率低。

因此，效率更高的实现思路是只锁一部分，先判断instance是否存在：如果存在，则直接返回instance；如果不存在，则获取锁并创建对象。

我们来看一下新的代码有什么问题：

package com.java.www.day20210101;

class SingleInstanceLazy{
    // 此时不创建
    private static SingleInstanceLazy instance;

    static SingleInstanceLazy getInstance(){
        // 校验
        if (instance==null){
            // 加锁
            synchronized (SingleInstanceLazy.class){
                instance = new SingleInstanceLazy();	// (***)
            }
        }
        // 实例如果存在了则返回
        return instance;
    }
}

public class SingleInstanceLayTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                public void run() {
                    SingleInstanceLazy instance = SingleInstanceLazy.getInstance();
                    System.out.println(Thread.currentThread().getName()+"---"+instance);
                }
            }).start();
        }
    }
}

运行结果如下：

Thread-9---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-2---com.java.www.day20210101.SingleInstanceLazy@3d7c301d
Thread-6---com.java.www.day20210101.SingleInstanceLazy@3d7c301d
Thread-7---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-3---com.java.www.day20210101.SingleInstanceLazy@3d7c301d
Thread-1---com.java.www.day20210101.SingleInstanceLazy@3d7c301d
Thread-0---com.java.www.day20210101.SingleInstanceLazy@5169ce60
Thread-5---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-8---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-4---com.java.www.day20210101.SingleInstanceLazy@5169ce60

Process finished with exit code 0

结果上述代码依然存在线程安全问题。

原因是：线程A和B可能都进入到代码当中加锁之前的位置，准备加锁，虽然加锁是同步互斥的，但是如果都进入到这个位置，说明两个线程都认为instance不存在，那么都会去创建对象，依然不能保证单例，synchronized只是保证了单例的创建是原子的，但是无法保证单例的判断和创建这个两个步骤是单例的。

解决办法是，加锁之后，再次判断instance是否存在，代码如下：

package com.java.www.day20210101;

class SingleInstanceLazy{
    // 此时不创建
    private static SingleInstanceLazy instance;

    static SingleInstanceLazy getInstance(){
        // 第一次校验
        // (*)
        if (instance==null){
            // 加锁
            synchronized (SingleInstanceLazy.class){
                // 第二次校验
                if (instance==null){
                    instance = new SingleInstanceLazy();   // (***)
                }
            }
        }
        // 实例如果存在了则返回
        return instance;
    }
}

public class SingleInstanceLayTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                public void run() {
                    SingleInstanceLazy instance = SingleInstanceLazy.getInstance();
                    System.out.println(Thread.currentThread().getName()+"---"+instance);
                }
            }).start();
        }
    }
}

运行结果为：

Thread-4---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-6---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-2---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-7---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-5---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-8---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-9---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-0---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-3---com.java.www.day20210101.SingleInstanceLazy@7e437185
Thread-1---com.java.www.day20210101.SingleInstanceLazy@7e437185

Process finished with exit code 0

可见是线程安全的。上述代码被称为双重校验加锁(Double Check and Lock, DCL)的方法，双重校验加锁是效率最高且线程安全的单例实现方式。

有序性

上述代码当中，(***)标识的代码instance = new SingleInstanceLazy();，虽然是简简单单的一句代码，却包含了三个过程：

在内存开辟一块空间并获得这块空间的地址
在这块空间new出一个新对象
将地址赋值给instance

在某些时刻，为了优化执行效率，这3个过程可能存在CPU指令重排，可能出现：先开辟空间，然后再将地址赋值给instance，最后再创建一个新的对象，即按照1---3---2的顺序执行。

如果是这样，那么线程A在步骤1和3执行之后，还没执行步骤2，此时如果另一个线程B进入到(*)标识的位置处，判断引用instance不是null就直接返回了，但是实际上instance对应的地址内存处没有对象创建(线程A还没创建)，那么线程B拿到的是一个空对象，会发生空指针异常，这就是有序性的问题。

避免CPU指令重排可以使用volatile关键字去修饰instance，那么上述语句将按照1---2---3的顺序执行，这样instance引用被赋值的时候，一定会被赋予一个有对象的内存地址，就保证了多线程下的有序性。

因此，最终目前最完善的单例懒汉式的代码如下所示：

package com.java.www.day20210101;

class SingleInstanceLazy{
    // 此时不创建
    // volatile保证有序性，避免CPU指令重排，从而避免空指针异常
    private static volatile SingleInstanceLazy instance;

    static SingleInstanceLazy getInstance(){
        // 第一次校验
        if (instance==null){
            // 加锁
            synchronized (SingleInstanceLazy.class){
                // 第二次校验
                if (instance==null){
                    instance = new SingleInstanceLazy();
                }
            }
        }
        // 实例如果存在了则返回
        return instance;
    }
}

public class SingleInstanceLayTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                public void run() {
                    SingleInstanceLazy instance = SingleInstanceLazy.getInstance();
                    System.out.println(Thread.currentThread().getName()+"---"+instance);
                }
            }).start();
        }
    }
}

结语

有序性问题很难通过运行代码的结果体现出来，只能通过逻辑分析证明存在CPU指令重排的问题。这也警示着我们：写出来的代码运行了100次没有出问题，不代表第101次没有问题，面向debug编程不是长久之计，从原理出发才有可能写出高质量的代码。
Java高并发的三大特征：原子性、可见性、有序性在单例懒汉模式中都得到了体现。synchronized不仅保证了原子性，还保证了可见性。如果有人说双重校验加锁的单例懒汉式当中加volatile的作用是保证可见性，不对，volatile固然可以保证可见性，但在这里是为了避免CPU指令重排。
上面虽然说了synchronized保证了可见性，但是涉及具体的场景，需要具体问题具体分析。

梦想总是要不可及，是不是应该放弃

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
[面试Java]线程安全的单例模式之饿汉和懒汉实现

导言单例模式是最常用的一种设计模式，常用于获取公共对象的代码中。例如：mysql数据库连接池文件系统HDFS的连接FileSystem对象Spark的上下文对象SparkContext全局的计数器全局的日志对象Logger用户不希望创建多个对象，而是当一个对象创建之后不再创建，其他线程如果需要直接获取不需要重复创建，也希望通过这个单例对象共享数据，因此单例模式，在计算机编程中，是比较常用的一种设计模式。然而，单例模式常常出现在多线程并发的场景中，写出一个线程安全、效率高、开销小的单例模式，
复制链接

扫一扫