java多线程（六）关键字Volatile可见性、有序性以及单个变量的原子性

veminhe

已于 2024-08-23 10:44:26 修改

阅读量631

点赞数 21

分类专栏： JAVA 多线程-并发文章标签： java

于 2024-08-22 18:16:52 首次发布

本文链接：https://blog.csdn.net/heming20122012/article/details/141434208

版权

JAVA 同时被 2 个专栏收录

83 篇文章 2 订阅

订阅专栏

多线程-并发

11 篇文章 0 订阅

订阅专栏

volatile关键字

作用

volatile 是 Java 虚拟机提供的轻量级的同步机制，主要用来确保变量被线程安全地读取和写入。

当一个变量定义为 volatile 后，它具备以下特性：

可见性：确保不同线程对这个变量操作的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
有序性：禁止进行指令重排序优化。

实现原理

在 Java 内存模型中，每个线程在运行时都有自己的工作内存，其中存放着主内存中变量副本的拷贝。

当线程对变量进行修改时，首先修改的是自己工作内存中的副本，然后线程再将修改后的副本值刷新到主内存中。

当其他线程需要读取该变量时，会从主内存中重新读取最新的副本到自己的工作内存中。

volatile 变量的特殊规则如下：

每次使用前都需要从主内存中刷新最新的值，保证读取的总是最新的数据。
每次修改后都需要立即同步回主内存中，保证其他线程可以看到最新的值。

使用场景

状态标记量：如中断标记、状态标记等。
单例模式的双重检查锁定：防止指令重排序。

注意事项

volatile 变量不适合作为状态的复合操作，因为 volatile 不能保证复合操作的原子性。
volatile 只能保证变量的可见性和有序性，不能保证原子性。

volatile示例讲解

1. 可见性

Volatile保证了变量的可见性，即当一个线程修改了某个变量的值，这个新值对其他线程来说是立即可见的。

反面代码示例：不使用volatile时，可能导致线程读取到过时数据。

package com.hmblogs.backend.study.thread;

public class VolatileExample {
    // 假设threadA和threadB同时访问isFlag变量，且没有使用volatile关键字
    static boolean isFlag = false;
    public static void main(String[] args) throws InterruptedException {


        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            // thread1中执行
            isFlag = true;
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running");
            // thread2中执行
            if (!isFlag) {
                // 这里的代码可能会执行，即使isFlag已经被thread1设置为true
                System.out.println("isFlag 是 false.");
            }
        });

        thread1.start();
        thread2.start();

        System.out.println("Both threads have finished their execution");
    }
}

正面代码示例：使用volatile确保变量值的实时更新。

package com.hmblogs.backend.study.thread;

public class VolatileExample {
    // 假设threadA和threadB同时访问isFlag变量，且没有使用volatile关键字
    volatile static boolean isFlag = false;
    public static void main(String[] args) throws InterruptedException {


        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            // thread1中执行
            isFlag = true;
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running");
            // thread2中执行
            if (!isFlag) {
                // 这里的代码可能会执行，即使isFlag已经被thread1设置为true
                System.out.println("isFlag 是 false.");
            }
        });

        thread1.start();
        thread2.start();

        System.out.println("Both threads have finished their execution");
    }
}

验证结果：volatile没有对应的特性。这是什么原因呢？

2. 原子性

Volatile对单个变量的读写具有原子性，但复合操作（如i++）不是原子的。

反面代码示例：volatile变量在复合操作中可能出现问题。

package com.hmblogs.backend.study.thread;

public class VolatileExample {
    static volatile int counter = 0;
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            // thread1中执行
            counter++;
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running");
            // thread2中执行
            System.out.println("counter 是 "+counter+".");
        });

        thread1.start();
        thread2.start();

        System.out.println("Both threads have finished their execution");
    }
}

有时候打印的是1，有时候是0

正面代码示例：使用synchronized或原子类来保证复合操作的原子性。

package com.hmblogs.backend.study.thread;

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileExample {
    static volatile AtomicInteger counter = new AtomicInteger();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            // thread1中执行
            int temp = counter.getAndAdd(1);
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running");
            // thread2中执行
            System.out.println("counter 是 "+counter.get()+".");
        });

        thread1.start();
        thread2.start();

        System.out.println("Both threads have finished their execution");
    }
}

一直都是0.

验证结果：volatile没有对应的特性。这是什么原因呢？

3. 有序性

Volatile变量还可以确保指令的有序性，防止JVM进行指令重排序。

反面代码示例：不使用volatile时，JVM可能进行指令重排序。

int a = 0;
boolean flag = false; // 假设这里不使用volatile
int b = 0;

// 线程A执行
a = 1; // Step 1
flag = true; // Step 2
b = 2; // Step 3

// 线程B执行
if (flag) {
    // JVM可能重排序，导致线程B先看到b=2，再看到a=1
}

正面代码示例：使用volatile防止指令重排序。

int a = 0;
volatile boolean flag = false;
int b = 0;

// 线程A执行
a = 1; // Step 1
flag = true; // Step 2，volatile变量，确保前面操作不会重排序到后面
b = 2; // Step 3

// 线程B执行
if (flag) {
    // 确保先看到a=1，再看到b=2
}