【Java并发处理代码规范】之通过volatile解决双重检查锁的延迟初始化问题

Java代码规范之通过volatile解决双重检查锁的延迟初始化问题

目录

• 该条规范是什么
• 为什么这么规定
• volatile 原理和示例

该条规范是什么

该规范指出在Java编程中，在并发场景下，通过双重检查锁（double-checked locking）实现延迟初始化时存在优化问题隐患。为了解决这个问题，推荐将目标属性声明为volatile型，即使用volatile关键字修饰变量。

为什么这么规定

以下是该规范的原因：

1. 优化问题隐患：在并发环境下，双重检查锁可能存在优化问题，导致初始化代码被重排序，从而可能引发线程安全问题。这是由于指令重排序和内存可见性问题所导致的。
2. 使用volatile解决：将目标属性声明为volatile型可以保证在多线程环境下对变量的读写操作具有原子性和可见性，从而避免了双重检查锁的优化问题。

多种主要用法及其代码示例

以下是一个使用双重检查锁模式实现的单例示例代码：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // 私有化构造函数
    }

    public static Singleton getInstance() {
        if (instance == null) {  // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) {  // 第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

volatile 原理和示例

volatile 是 Java 中的一个关键字，用于修饰变量。它主要用于保证变量的可见性和禁止指令重排序。

原理

当一个变量被声明为 volatile 时，Java 内存模型会确保所有线程对该变量的读写操作都是直接从主内存中进行的，而不是从线程的本地缓存中获取。

• 可见性：使用 volatile 修饰的变量，在一个线程中的修改对其他线程是可见的。即当一个线程修改了 volatile 变量的值后，其他线程可以立即看到这个修改。
• 禁止指令重排序：使用 volatile 修饰的变量的读写操作会被限制在 volatile 变量的前后，防止指令重排序导致的意外结果。

volatile 关键字通过使用内存屏障（Memory Barrier）和禁止指令重排序来实现可见性和有序性。

示例

下面是一个使用 volatile 的示例代码：

public class Example {
    private static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread writerThread = new Thread(() -> {
            try {
                Thread.sleep(1000);
                flag = true; // 修改 volatile 变量的值
                System.out.println("Flag is set to true.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread readerThread = new Thread(() -> {
            while (!flag) {
                // 等待 flag 变为 true
            }
            System.out.println("Flag is true. Reader thread finished.");
        });

        writerThread.start();
        readerThread.start();

        writerThread.join();
        readerThread.join();
    }
}

在上述示例中，创建了一个 volatile 的 boolean 类型变量 flag。然后启动了两个线程：writerThread 和 readerThread。writerThread 在一段时间后将 flag 设置为 true，而 readerThread 不断检查 flag 是否为 true。当 flag 变为 true 时，readerThread 输出相应的信息并结束。

运行示例代码会输出类似以下内容：

Flag is set to true.
Flag is true. Reader thread finished.

可以看到，在 volatile 变量的修改后，readerThread 立即看到了这个修改，并完成了自己的任务。

这个示例展示了 volatile 的可见性特性，它确保了一个线程对 volatile 变量的修改对其他线程是可见的。