Java并发练习：高性能创建单例，面试必备

目标：高性能的创建单例

关键问题

• 避免并发创建多个单例
• 降低锁消耗大量性能

volatile

• 确保语义上对变量的读、写操作顺序被观察到。
• volatile变量读写时会增加内存屏障。
• volatile变量读写时会禁用局部指令重排。
• 保证对volatile的操作happens-before另一个操作。

AtomicReference

• 关键方法getAcquire()与setRelease()，它们可以确保代码不被重排序。
• AtomicReference与volatile的功能相似，但是它对于代码的指令重排是弱排序——发生在AtomicReference读写之前或之后的代码顺序不重要，只确保发生之前的代码确实在读写前面，发生之后的代码确实在读写后面。
• volatile是强排序的，代码的顺序不允许改变。

代码演示：

package com.miracle.study.vola;

import java.util.concurrent.atomic.AtomicReference;

/**
 * @author Miracle
 * @date 2021/4/15 15:43
 */
public class SingletonTest {

    /**
     * 基于volatile的演示
     */
    static class SingletonJava8 {

        private SingletonJava8(){}

        private static volatile SingletonJava8 singletonJava8;

        public static SingletonJava8 getInstance(){
            // 判断对象是否已初始化
            if (singletonJava8 == null){
                // 避免出现多个对象被创建，需要上锁
                synchronized (SingletonJava8.class){
                    // 再次判断对象是否已被初始化，第一个进来的线程已经完成对象初始化了，之后的线程全部直接获取对象返回
                    if (singletonJava8 == null){
                        // 查看成功创建对象的线程信息
                        System.out.println(Thread.currentThread());
                        // 创建对象
                        singletonJava8 = new SingletonJava8();
                    }
                }
            }
            return singletonJava8;
        }
    }

    /**
     * 基于Java9提供的AtomicReference演示
     */
    static class SingletonJava9 {

        private SingletonJava9(){}

        private static AtomicReference<SingletonJava9> singletonTwo = new AtomicReference<>();

        public static SingletonJava9 getInstance(){
            // 获取实例，并确保不进行重排序
            var singleton = singletonTwo.getAcquire();
            // 判断对象是否已初始化
            if (singleton == null){
                // 避免出现多个对象被创建，需要上锁
                synchronized (SingletonJava9.class){
                    // 重新获取一次对象，并确保不进行重排序
                    singleton = singletonTwo.getAcquire();
                    // 再次判断对象是否已被初始化，第一个进来的线程已经完成对象初始化了，之后的线程全部直接获取对象返回
                    if (singleton == null){
                        // 查看成功创建对象的线程信息
                        System.out.println(Thread.currentThread());
                        // 创建对象，并确保不进行重排序
                        singletonTwo.setRelease(new SingletonJava9());
                    }
                }
            }
            return singleton;
        }
    }

    public static void main(String[] args) {

        for (int i = 0; i < 10000; i++){
            new Thread(() ->{
                SingletonJava8.getInstance();
                SingletonJava9.getInstance();
            }).start();
        }
    }
}