Java volatile 之禁止指令重排序

╰+哭是因爲堅強的太久メ 2021-07-25 00:11 461阅读 0赞

# 一 单例的演变 #

## **a 饿汉式** ##

**1 代码**

/**
    * 饿汉式
    * 类加载到内存后，就实例化一个单例，JVM 保证线程安全
    * 简单实用，推荐使用
    * 唯一缺点：不管用到与否，类装载时就完成实例化。
    */
    public class Mgr01 {
        private static final Mgr01 INSTANCE = new Mgr01();
    
        private Mgr01() {
        }
    
        public static Mgr01 getInstance() {
            return INSTANCE;
        }
    
        public static void main(String[] args) {
            Mgr01 m1 = getInstance();
            Mgr01 m2 = getInstance();
            System.out.println(m1 == m2);
        }
    }

**2 测试**

> true

## b 通过静态代码块实现 ##

**1 代码**

public class Mgr02 {
        private static final Mgr02 INSTANCE;
    
        static {
            INSTANCE = new Mgr02();
        }
    
        private Mgr02() {
        }
    
        public static Mgr02 getInstance() {
            return INSTANCE;
        }
    
        public static void main(String[] args) {
            Mgr02 m1 = getInstance();
            Mgr02 m2 = getInstance();
            System.out.println(m1 == m1);
        }
    }

**2 测试**

> true

## c 懒汉式——非线程安全 ##

**1 代码**

/**
    * 懒汉式：什么时候用，什么时候初始化
    * 非线程安全
    */
    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 static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(() -> {
                    System.out.println(Mgr03.getInstance().hashCode());
                }).start();
            }
        }
    }

**2 测试**

> 2033291474
> 
> 823004921
> 
> 2118558849
> 
> 1273086253
> 
> 1851926792
> 
> 1309188278
> 
> 1851926792
> 
> 157337118
> 
> 270427352
> 
> 11204854

## d 懒汉式——线程安全 ##

**1 代码**

/**
    * Lazy loading
    * 懒汉式：什么时候用，什么时候初始化
    * 可以通过 synchronized 解决非线程安全问题，但是也让效率降低了很多。
    */
    public class Mgr04 {
        private static Mgr04 INSTANCE;
    
        private Mgr04() {
        }
    
        public static synchronized Mgr04 getInstance() {
            if (INSTANCE == null) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr04();
            }
            return INSTANCE;
        }
    
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(() -> {
                    System.out.println(Mgr04.getInstance().hashCode());
                }).start();
            }
        }
    }

**2 测试**

> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854

## e 加锁代码细化，从锁整个方法下移到方法体内某个代码片段 ##

**1 代码**

/**
    * 判断之后，给代码块加锁，任然不能解决线程安全问题
    */
    public class Mgr05 {
        private static Mgr05 INSTANCE;
        private Mgr05() {
        }
    
        public static Mgr05 getInstance() {
            if (INSTANCE == null) {
                synchronized (Mgr05.class) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr05();
                }
            }
            return INSTANCE;
        }
    
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(() -> System.out.println(Mgr05.getInstance().hashCode())).start();
            }
        }
    }

**2 测试**

> 2118558849
> 
> 270427352
> 
> 823004921
> 
> 1273086253
> 
> 1851926792
> 
> 157337118
> 
> 1309188278
> 
> 2033291474
> 
> 1152183952
> 
> 11204854

## f 懒汉式——双重判断可以保证线程安全 ##

**1 代码**

/**
    * 懒汉式，双重判断可以保证线程安全
    */
    public class Mgr06 {
        // 在非超高并发情况下，虽然不加 volatile，代码也能运行正确，这里一定要加 volatile，防止指令重排，在超高并发情况下出问题
        private static volatile Mgr06 INSTANCE;
    
        private Mgr06() {
        }
    
        public static Mgr06 getInstance() {
            if (INSTANCE == null) {
                //双重检查
                synchronized (Mgr06.class) {
                    if (INSTANCE == null) {
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        INSTANCE = new Mgr06();
                    }
                }
            }
            return INSTANCE;
        }
    
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(() -> System.out.println(Mgr06.getInstance().hashCode())).start();
            }
        }
    }

**2 测试**

> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854
> 
> 11204854

# 二 小结 #

**1 实例化一个对象三步走**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70][]

**2 代码证明**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1][]

**3 如果发生指令重排序，比如先执行第 1 步，再执行第 3 步，最后执行第 2 步，在执行完第 3 步后，INSTANCE 里变量的值就是 0 了，会出现问题。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70]: /images/20210724/e321f324a97f43e099b7405af74d2c28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1]: /images/20210724/834760608d2246788fa043e1338329fb.png