java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java  volatile 关键字

Java volatile 关键字介绍与使用示例详解

作者：栗筝i

这篇文章详细介绍了Java中的volatile关键字,包括它的核心特性、如何保证变量的可见性和有序性,以及它在解决多线程问题中的局限性,文章通过示例展示了如何在实际编程中使用volatile,并解释了如何通过其他同步机制来弥补volatile的不足,感兴趣的朋友一起看看吧

大家好，我是栗筝i，这篇文章是我的 “栗筝i 的 Java 技术栈” 专栏的第 026 篇文章，在 “栗筝i 的 Java 技术栈” 这个专栏中我会持续为大家更新 Java 技术相关全套技术栈内容。专栏的主要目标是已经有一定 Java 开发经验，并希望进一步完善自己对整个 Java 技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同学学习。当然，我也会在必要的时候进行相关技术深度的技术解读，相信即使是拥有多年 Java 开发经验的从业者和大佬们也会有所收获并找到乐趣。

–

在现代多线程编程中，确保数据的一致性和正确性是至关重要的。Java 作为一种广泛使用的编程语言，为多线程编程提供了丰富的工具和机制，其中 volatile 关键字是一个关键的概念。volatile 关键字在 Java 中被用来修饰变量，以确保它们在多线程环境下的可见性和有序性，但它并不保证操作的原子性。

理解 volatile 的工作原理及其应用场景，对于编写高效和可靠的多线程程序至关重要。在本文中，我们将深入探讨 volatile 关键字的核心特性，解释它如何确保变量的可见性和有序性，以及它在解决多线程问题中的局限性。我们还将通过示例展示如何在实际编程中使用 volatile，以及如何通过其他同步机制来弥补 volatile 的不足。

通过对 volatile 的详细分析，我们希望读者能够更好地理解在多线程环境中变量访问的复杂性，并掌握在实际开发中如何正确使用 volatile 关键字，以编写出更加健壮和高效的并发程序。

1、volatile 关键字简介

volatile 关键字在 Java 中用于修饰变量，使其具有可见性和有序性。

需要注意的是 volatile 仅能保证可见性和有序性，不能保证原子性。例如，volatile int count 的递增操作 count++ 仍然不是线程安全的，因为它包含了读和写两个操作，可能会被其他线程打断。

在复杂的同步场景中，可能需要使用 synchronized 或其他并发工具来确保线程安全。

2、volatile 保证可见性

在多线程编程中，线程之间共享变量的访问可能会出现可见性问题，即一个线程对变量的修改可能不会被其他线程立即看到。Java 提供了 volatile 关键字来解决这种可见性问题。

2.1、什么是可见性问题

当一个线程修改了某个变量的值，如果这个修改对其他线程是不可见的，可能会导致程序出现非预期的行为。例如，一个线程修改了变量 flag 的值，但其他线程仍然读取的是旧值：

public class VisibilityProblem {
    private boolean flag = true;
    public void stop() {
        flag = false;
    }
    public void run() {
        while (flag) {
            // 执行任务
        }
    }
}

在这个例子中，如果 flag 变量没有被声明为 volatile，当一个线程调用 stop 方法将 flag 设置为 false 后，另一个正在运行 run 方法的线程可能无法立即看到这个变化，仍然会在 while (flag) 循环中继续执行。

2.2、volatile 如何保证可见性

volatile 关键字通过以下机制确保变量的可见性：

示例代码：

public class VolatileExample {
    private volatile boolean running = true;
    public void stop() {
        running = false;
    }
    public void run() {
        while (running) {
            // 执行任务
        }
    }
    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        Thread thread = new Thread(example::run);
        thread.start();
        try {
            Thread.sleep(1000); // 让线程运行一段时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        example.stop(); // 停止线程
    }
}

在这个例子中，running 变量被声明为 volatile，确保 stop 方法对 running 的修改能够立即被 run 方法中的循环检测到。

3、volatile 保证有序性

在多线程编程中，指令重排序（Instruction Reordering）可能会导致程序的执行顺序与代码的书写顺序不一致，从而引发不可预测的问题。volatile 关键字通过内存屏障（Memory Barrier）机制，防止指令重排序，确保代码执行的有序性。

3.1、什么是指令重排序

为了优化程序的执行速度，编译器和处理器会对指令进行重排序。重排序包括以下三种类型：

尽管重排序不会改变单线程程序的语义，但在多线程环境下，重排序可能会导致线程间的操作顺序不一致，从而引发数据竞争和线程安全问题。

3.2、volatile 如何保证有序性

volatile 关键字通过插入内存屏障，确保指令的执行顺序。内存屏障是一种同步机制，防止特定类型的指令在重排序时被移动到屏障的另一侧。volatile 变量的读写操作前后会插入内存屏障，确保有序性：

具体而言，volatile 保证了以下两点：

写 volatile 变量之前的所有写操作不会被重排序到 volatile 写之后；读 volatile 变量之后的所有读操作不会被重排序到 volatile 读之前。

示例代码：

public class VolatileOrderingExample {
    private volatile boolean flag = false;
    private int a = 0;
    public void writer() {
        a = 1;         // 写普通变量
        flag = true;   // 写volatile变量
    }
    public void reader() {
        if (flag) {    // 读volatile变量
            int i = a; // 读普通变量
            // `i` 将是 1，因为 `flag` 为 true 时，`a` 必定已经被写为 1
        }
    }
}

在这个例子中，writer 方法中对 a 的写操作不会被重排序到 flag 之后，因此在 reader 方法中，一旦检测到 flag 为 true，就能确保读取到的 a 的值是最新的 1。

4、volatile 不保证原子性的详细介绍

在多线程编程中，volatile 关键字可以保证变量的可见性和有序性，但不能保证操作的原子性。原子性（Atomicity）指的是操作在执行过程中不可分割，要么全部执行，要么全部不执行。

4.1、什么是原子性问题

在多线程环境下，非原子操作可能会导致数据不一致。例如，自增操作 i++ 看似简单，但它实际上由三步组成：

这三步操作在多线程环境下可能会被打断，从而导致数据竞争问题。假设两个线程同时执行 i++ 操作：

最终结果是，虽然两个线程都执行了 i++ 操作，但 i 的值只增加了 1。这就是因为 i++ 操作不是原子的。

4.2、volatile 的局限性

volatile 仅能确保变量的可见性和有序性，但不能确保操作的原子性。换句话说，使用 volatile 修饰的变量虽然可以在多个线程之间及时同步，但多个线程对该变量的复合操作（如自增、自减）仍然会存在数据竞争问题。

以下是一个例子，说明了 volatile 不保证原子性的问题：

public class VolatileNonAtomic {
    private volatile int count = 0;
    public void increment() {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        VolatileNonAtomic example = new VolatileNonAtomic();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final count: " + example.count);
    }
}

在这个例子中，尽管 count 变量被声明为 volatile，但由于 increment 方法中的 count++ 操作不是原子的，最终的 count 值可能小于 2000。

4.3、解决方法

为了确保操作的原子性，可以使用以下方法：

使用 synchronized 关键字：将操作包装在同步块中，确保操作的原子性。

public class SynchronizedExample {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
}

使用原子类：Java 提供了 java.util.concurrent.atomic 包中的原子类（如 AtomicInteger、AtomicLong）来确保操作的原子性。

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();
    }
}

到此这篇关于Java volatile 关键字介绍与使用的文章就介绍到这了,更多相关java volatile 关键字内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文