粉丝答疑：如何使用双重检查锁定在 Java 中创建线程安全的单例？

最新推荐文章于 2024-05-06 22:08:40 发布

黑客大白

最新推荐文章于 2024-05-06 22:08:40 发布

阅读量1k

点赞数 11

分类专栏：互联网程序员计算机文章标签： java 安全单例模式

本文链接：https://blog.csdn.net/Libra1313/article/details/137217294

版权

程序员同时被 3 个专栏收录

256 篇文章 4 订阅

订阅专栏

计算机

256 篇文章 1 订阅

订阅专栏

互联网

255 篇文章 1 订阅

订阅专栏

之前大白在直播的时候，有个粉丝朋友询问了大白java相关的专业问题。

大白的话，也只能先从两个if语句做检查，建议他入手。

完整的解析，大白也根据自己的专业知识，可以帮大家过滤掉一些信息。大白也推荐粉丝朋友看看网友的这篇文章。有比较详尽的解释。

🍈一. 使用多线程需要考虑的因素

提高效率： 使用多线程就是为了充分利用CPU资源，提高任务的效率
线程安全： 使用多线程最基本的就是保障线程安全问题

所以我们在设计多线程代码的时候就必须在满足线程安全的前提下尽可能的提高任务执行的效
故：
加锁细粒度化：加锁的代码少一点，让其他代码可以并发并行的执行

🍬考虑线程安全：

没有操作共享变量的代码没有安全问题
对共享变量的读，使用volatile修饰变量即可
对共享变量的写，使用synchronized加锁

🍊二. 单例模式

单例模式能保证某个类在程序中只存在唯一一份实例，而不会创建出多个实例
例如：DataSource（数据连接池），一个数据库只需要一个连接池对象

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

🌴1. 饿汉模式

饿汉模式是在类加载的时候就创建实例
这种方式是满足线程安全的（JVM内部使用了加锁，即多个线程调用静态方法，只有一个线程竞争到锁并且完成创建，只执行一次）

👁‍🗨️实现代码：

public class Singleton {  
   
    //类加载阶段就会创建实例  
    private static Singleton instance = new Singleton();  
   
    //为了防止不小心new了这个SingletonEH,所构造方法访问权限为private  
    private Singleton(){  
   
    }  
    //提供一个方法可以让外边能够拿到这个实例  
    public static Singleton getInstance(){  
        return instance;  
    }  
}

🌾2. 懒汉模式

懒汉模式是在类加载的时候不创建实例，第一次使用的时候才创建

👁‍🗨️实现代码：

public class Singleton {  
    private static Singleton instance = null;  
    private Singleton(){  
   
    }  
    public static Singleton getInstance(){  
        if(instance == null){  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

观察上述代码，在单线程下不存在线程安全问题，但是在多线程环境下存在安全问题吗？

分析：
🍃当实例没有被创建的时候，如果有多个线程都调用getInstance方法，就可能创建多个实例，就存在线程安全问题
🍃但是实例一旦创建好，后面线程调用getInstance方法就不会出现线程安全问题

结果： 线程安全问题出现在首次创建实例的时候

🌵3. 懒汉模式（使用synchronized改进）

我们使用sychronized修饰，👁‍🗨️代码如下：

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

这样实现线程安全存在什么问题呢？

解析：
我们对方法使用synchronized修饰，也就是每次调用该方法的时候都会竞争锁，但是创建实例只需要创建一次，也就是创建实例后，再调用该方法还需要竞争锁释放锁

结果： 虽然满足线程安全，但是效率低

🌳4. 懒汉模式（使用双重校验锁改进）

在上述代码的基础上进行改动：

使用双重if判定，降低竞争锁频率
使用volatile修饰instance

👁‍🗨️实现代码：

public class Singleton {  
    //加volatile的原因：禁止指令重排序  
    private static volatile Singleton instance = null;  
    private Singleton(){  
   
    }  
    public static Singleton getInstance(){  
        if(instance == null){ //外层的if判断：如果实例被创建直接return，不让线程再继续竞争锁  
            //在没有创建实例时，多个线程已经进入if判断了  
            //一个线程竞争到锁，其他线程阻塞等待  
            synchronized (Singleton.class) {  
                //内层的if判断，目的是让竞争失败的锁如果再次竞争成功的话判断实例是否被创建，创建释放锁return，没有则创建  
                if(instance == null){   
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

🍬对双重if的解析：

🍂外层的if判断：实例只是被创建一次，当实例已经被创建好了就不要后续操作，直接return返回

🍂内层的if判断：实例未被创建时，多个线程同时竞争锁，只有一个线程竞争成功并创建实例，其他竞争失败的线程就会阻塞等待，当第一线程释放锁后，这些竞争失败的线程就会继续竞争，但是实例已经创建好了，所以需要再次进行if判断

画图分析，如下所示：

🌾5. 静态内部类

饿汉式单例类不能实现延迟加载，不管将来用不用始终占据内存,懒汉式单例类线程安全控制烦琐，而且性能受影响

静态内部类实现单例模式就可以克服以上两种单例模式的缺点,如下所示👇

👁‍🗨️实现代码：

 public class Singleton {  
   
    private static class HolderClass{  
        private static final Singleton instance = new Singleton();  
    }  
   
    public static Singleton getInstance(){  
        return HolderClass.instance;  
    }  
}

由于静态单例对象没有作为Singleton的成员变量直接实例化，因此类加载时不会实例Singleton，第一次调用getInstance()时将加载内部类HolderClass，在该内部类中定义了一个static类型的变量instance，此时会首先初始化这个成员变量，由Java虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定，因此其性能不会造成任何影响。

🌵6. 枚举

枚举是在JDK1.5以及以后版本中增加的一个“语法糖”，它主要用于维护一些实例对象固定的类。例如一年有四个季节，就可以将季节定义为一个枚举类型，然后在其中定义春、夏、秋、冬四个季节的枚举类型的实例对象。按照Java语言的命名规范，通常，枚举的实例对象全部采用大写字母定义，这一点与Java里面的常量是相同的。

👁‍🗨️实现代码：

public enum Singleton {  
     INSTANCE;  
     public void businessMethod() {  
          System.out.println("我是一个单例！");  
     }  
}

🥭三. volatile的原理

volatile保证了可见性，有序性，在Java层面看，volatile是无锁操作，多个线程对volatile修饰的变量进行读可以并发并行执行，和无锁执行效率差不多

volatile修饰的变量中，CPU使用了缓存一致性协议来保证读取的都是最新的主存数据

缓存一致性：如果有别的线程修改了volatile修饰的变量，就会把CPU缓存中的变量置为无效，要操作这个变量就要从主存中重新读取