java单例模式的线程安全 JAVA多线程编程中的双重检查锁定（DCL单例（Double Check Lock））

深碍√TFBOYSˉ_ 2024-03-23 10:54 29阅读 0赞

#### java单例模式的线程安全 JAVA多线程编程中的双重检查锁定（DCL单例（Double Check Lock）） ####

*  一、饿汉模式单例（本身及时线程安全的）
 *  二、懒汉模式单例
 *   *  1.懒汉模式第一版，用INSTANCE == null判断是否初始化（非线程安全）
     *  2.懒汉模式第二版,方法加synchronized锁（线程安全，但是效率太慢）
     *  3.懒汉模式第三版,方法中加synchronized代码块锁（线程不安全）
     *  4.懒汉模式第四版,DCL单例（Double Check Lock）加volatile关键字（线程安全）
     *   *  volatile作用：

此文章链接 https://blog.csdn.net/wuyuanshun/article/details/130101511

## 一、饿汉模式单例（本身及时线程安全的） ##

*  饿汉式
 *  类加载到内存后，就实例化一个单例，JVM保证线程安全
 *  简单实用，推荐使用！
 *  唯一缺点：不管用到与否，类装载时就完成实例化

/**
    https://blog.csdn.net/wuyuanshun/article/details/130101511
     * @program: algorithm
     * @description: 饿汉式
     * 类加载到内存后，就实例化一个单例，JVM保证线程安全
     * 简单实用，推荐使用！
     * 唯一缺点：不管用到与否，类装载时就完成实例化
     * @author: wuyuanshn
     * @create: 2023-04-07 16:24
     **/
    public class Mgr01 {
        
        private static final Mgr01 INSTANCE = new Mgr01();
    
        private Mgr01() {
        
        }
    
        public static Mgr01 getInstance() {
        
            return INSTANCE;
        }
    
        public void m() {
        
            System.out.println("m");
        }
    
        public static void main(String[] args) {
        
            Mgr01 m1 = Mgr01.getInstance();
            Mgr01 m2 = Mgr01.getInstance();
            System.out.println(m1 == m2);
        }

## 二、懒汉模式单例 ##

### 1.懒汉模式第一版，用INSTANCE == null判断是否初始化（非线程安全） ###

*  懒汉模式
 *  虽然达到了按需初始化的目的，但却存在需求线程不安全的问题

/**
     * @program: algorithm
     * @description: lazy loading
     * 懒汉模式
     * 虽然达到了按需初始化的目的，但却存在需求线程不安全的问题
     * @author: wuyuanshn
     * @create: 2023-04-07 16:24
     **/
    public class Mgr03 {
        
        private static Mgr03 INSTANCE;
    
        private Mgr03() {
        
        }
    
        public static Mgr03 getInstance() {
        
            if (INSTANCE == null) {
        
                try {
        
                    Thread.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                INSTANCE = new Mgr03();
            }
            return INSTANCE;
        }
    
        public void m() {
        
            System.out.println("m");
        }
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Mgr03.getInstance().hashCode())
                ).start();
            }
        }
    }

### 2.懒汉模式第二版,方法加synchronized锁（线程安全，但是效率太慢） ###

*  懒汉模式
 *  虽然达到了按需初始化的目的，但却存在需求线程不安全的问题
 *  可以通过synchronized解决，但也带来效率下降

/**
     * @program: algorithm
     * @description: lazy loading
     * 懒汉模式
     * 虽然达到了按需初始化的目的，但却存在需求线程不安全的问题
     * 可以通过synchronized解决，但也带来效率下降
     * @author: wuyuanshn
     * @create: 2023-04-07 16:24
     * https://blog.csdn.net/wuyuanshun/article/details/130101511
     **/
    public class Mgr04 {
        
        private static Mgr04 INSTANCE;
    
        private Mgr04() {
        
        }
    
        public static synchronized Mgr04 getInstance() {
        
            //业务逻辑
            //xx
            //a
            if (INSTANCE == null) {
        
                try {
        
                    Thread.sleep(1);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                INSTANCE = new Mgr04();
            }
            return INSTANCE;
        }
    
        public void m() {
        
            System.out.println("m");
        }
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Mgr04.getInstance().hashCode())
                ).start();
            }
        }
    }

### 3.懒汉模式第三版,方法中加synchronized代码块锁（线程不安全） ###

*  懒汉模式
 *  可以通过synchronized解决，但也带来效率下降
 *  妄图通过减小同步代码块的方式提高效率，然后不可行，还是存在线程安全问题
 *  在INSTANCE == null和synchronized中间同时进入多个线程还是有问题

/**
     * @program: algorithm
     * @description: lazy loading
     * 也称懒汉模式
     * 虽然达到了按需初始化的目的，但却存在需求线程不安全的问题
     * 可以通过synchronized解决，但也带来效率下降
     * 妄图通过减小同步代码块的方式提高效率，然后不可行，还是存在线程安全问题 
     * 在INSTANCE == null和synchronized中间同时进入多个线程还是有问题
     * @author: wuyuanshn
     * @create: 2023-04-07 16:24
     **/
    public class Mgr05 {
        
        private static Mgr05 INSTANCE;
    
        private Mgr05() {
        
        }
    
        public static Mgr05 getInstance() {
        
            //业务逻辑
            //xx
            //a
            if (INSTANCE == null) {
        
                //妄图通过减小同步代码块的方式提高效率，然后不可行
                synchronized (Mgr05.class) {
        
                    try {
        
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr05();
                }
    
            }
            return INSTANCE;
        }
    
        public void m() {
        
            System.out.println("m");
        }
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Mgr05.getInstance().hashCode())
                ).start();
            }
        }
    }

### 4.懒汉模式第四版,DCL单例（Double Check Lock）加volatile关键字（线程安全） ###

*  懒汉模式
 *  虽然达到了按需初始化的目的，但却存在需求线程不安全的问题
 *  使用DCL单例（Double Check Lock）加volatile关键字解决线程问题

/**
     * @program: algorithm
     * @description: lazy loading
     * https://blog.csdn.net/wuyuanshun/article/details/130101511
     * 懒汉模式
     * 虽然达到了按需初始化的目的，但却存在需求线程不安全的问题
     * 使用DCL单例（Double Check Lock）加volatile关键字解决线程问题
     * @author: wuyuanshn
     * @create: 2023-04-07 16:24
     **/
    public class Mgr06 {
        
        private static /*volatile*/ Mgr06 INSTANCE;
    
        private Mgr06() {
        
        }
    
        public static Mgr06 getInstance() {
        
            //业务逻辑
            //xx
            //此文章链接 https://blog.csdn.net/wuyuanshun/article/details/130101511
            if (INSTANCE == null) {
        // Double Check Lock
                //双重检查锁
                synchronized (Mgr06.class) {
        
                    if (INSTANCE == null) {
        
                        try {
        
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        INSTANCE = new Mgr06();
                    }
                }
    
            }
            return INSTANCE;
        }
         /*
        NEW java/lang/Object      申请内存
        INVOKESPECIAL java/lang/Object.<init> ()V    赋值
        ASTORE 1    关联对象Object到o
             */
    
        public void m() {
        
            System.out.println("m");
        }
    
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Mgr06.getInstance().hashCode())
                ).start();
            }
        }
    }

以上代码使用了双重检查锁，但是还是存在线程安全问题，因为可能会出现代码指令重排序。重排序其实出现在字节码层级。在字节码层级Object o=new Object();  
是多条执行令如下：  
代码

public class TMain {
        
        public static void main(String[] args) {
        
            Object o=new Object();
        }
    }

![在这里插入图片描述][457ffa4c4247437c9eb7879221cb7c18.png]  
![在这里插入图片描述][d73abd01b6fa4ef1bd8a85c35cd84ae3.png]  
**字节码解释**  
NEW java/lang/Object 申请内存  
INVOKESPECIAL java/lang/Object. ()V 赋值  
ASTORE 1 关联对象Object到o

如果赋值和关联语句发生了代码重排序 ，及两句交换执行。就会出现先把对象关联到o，但是对象还没有初始化赋值。导致获取的对象异常。  
解决方案是在Mgr06 INSTANCE;前加 volatile关键字【禁止指令重排序（CPU）】

#### volatile作用： ####

1.保证线程可见性  
2.禁止指令重排序（CPU）  
此文章链接 https://blog.csdn.net/wuyuanshun/article/details/130101511  
[此文章链接][Link 1]

[457ffa4c4247437c9eb7879221cb7c18.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/98dd26776e304c4694b7ed8ee8b062c1.png
[d73abd01b6fa4ef1bd8a85c35cd84ae3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/1bb1991340b5469687994cbf3b2d532c.png
[Link 1]: https://blog.csdn.net/wuyuanshun/article/details/130101511