volatile引发的一个有趣的测试

最新推荐文章于 2025-07-24 13:32:30 发布
原创 最新推荐文章于 2025-07-24 13:32:30 发布 · 419 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了volatile关键字在Java中的作用，通过实例演示了它如何防止CPU指令重排序，但不能确保基于volatile变量的运算在多线程环境中是安全的。文章提供了多个测试案例，展示了synchronized和AtomicInteger在实现线程安全方面的效果。

转载请以链接形式标明出处：
本文出自:103style的博客

本文是 看到 这篇文章中 “volatile 的意义？” 那一小节提供的一个例子引发的测试。

volatile 的意义？

  • 防止CPU指令重排序

volatile有两条关键的语义：

  • 保证被volatile修饰的变量对所有线程都是可见的
  • 禁止进行指令重排序

下面的例子是用来证明下面这个观点的后半句是错误的。

由于volatile修饰的变量在各个线程里都是一致的，所以基于volatile变量的运算在多线程并发的情况下是安全的。

原测试示例

例子是这样的：

public class Test {
    private volatile int start = 0;
    public static void main(String[] args) {
        new Test().test();
    }
    private void test() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                add();
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
        System.out.println("start = " + start);
    }
    void add() {
        for (int i = 0; i < 10; i++) {
            start++;
        }
    }
}

大家可以看看 最后运行的结果输出的 start 值是多少 ?

给 add 方法加上 synchronized 之后

给 add() 方法加上 synchronized 之后输出的 start 值又是多少呢 ？

public class Test {
    private volatile int start = 0;
    public static void main(String[] args) {
        new Test().test();
    }
    private void test() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                add();
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
        System.out.println("start = " + start);
    }
    synchronized void add() {
        for (int i = 0; i < 10; i++) {
            start++;
        }
    }
}

两个测试的结果

两个结果都是 100？ 还是只有第二个是100 ?

其实两个结果都不是100，这是因为 main方法对应的线程 不会等待 新创建的线程执行完。

我们可以加上时间输出看看试试：

public class Test {
    private volatile int start = 0;
    public static void main(String[] args) {
        new Test().test();
    }
    private void test() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                add();
                System.out.println("new thread: " + System.currentTimeMillis());
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
        System.out.println("start = " + start);
        System.out.println("main: " + System.currentTimeMillis());
    }
    void add() {
        for (int i = 0; i < 10; i++) {
            start++;
        }
    }
}

控制台打印的结果：

new thread: 1583915204005
new thread: 1583915204005
new thread: 1583915204007
new thread: 1583915204007
new thread: 1583915204007
new thread: 1583915204007
start = 60
main: 1583915204007
new thread: 1583915204008
new thread: 1583915204008
new thread: 1583915204008
new thread: 1583915204008

可以看到 main方法对应的线程 先执行完了。

然后为了解决 main方法对应的线程 先执行完， 我们加上 Thread.sleep(1000); 看看：

public class Test {
    private volatile int start = 0;
    public static void main(String[] args) {
        new Test().test();
    }
    private void test() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                add();
                System.out.println("new thread: " + System.currentTimeMillis());
            }
        };
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("start = " + start);
        System.out.println("main: " + System.currentTimeMillis());
    }
    void add() {
        for (int i = 0; i < 10; i++) {
            start++;
        }
    }
}

查看控制台输出：

new thread: 1583915390819
new thread: 1583915390821
new thread: 1583915390822
new thread: 1583915390823
new thread: 1583915390823
new thread: 1583915390823
new thread: 1583915390823
new thread: 1583915390823
new thread: 1583915390823
new thread: 1583915390823
start = 100
main: 1583915391822

去掉修饰 start 的 volatile 修饰符

然后我们试试把 volatile 修饰符 去掉试试，运行的结果输出的 start 值是多少 ?

我们修改代码如下：

public class Test {
    private int start = 0;
    public static void main(String[] args) {
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            res.add(new Test().test());
        }
        System.out.println(res);
    }
    private int test() {
        Runnable runnable = () -> add();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(runnable);
            thread.start();
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return start;
    }
    void add() {
        for (int i = 0; i < 10; i++) {
            start++;
        }
    }
}

查看控制台输出：

[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100]

就不卖关子了，这里结果没问题的原因主要是因为 创建线程的耗时 比 add 方法执行的耗时还长， 所以就相当与单线程执行了，我们可以来验证下。

public class Test {
    private int start = 0;
    public static void main(String[] args) {
        new Test().test();
    }
    private int test() {
        for (int i = 0; i < 10; i++) {
            long t = System.nanoTime();
            Thread thread = new Thread(new TestRunnable(i));
            System.out.println(i + "_new_thred: " + (System.nanoTime() - t));
            thread.start();
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return start;
    }
    void add() {
        for (int i = 0; i < 10; i++) {
            start++;
        }
    }
    private class TestRunnable implements Runnable {
        int id;
        public TestRunnable(int i) {
            id = i;
        }
        @Override
        public void run() {
            long t = System.nanoTime();
            add();
            System.out.println(id + "_add: " + (System.nanoTime() - t));
        }
    }
}

查看控制台输出：

0_new_thred: 1232700
1_new_thred: 31800
2_new_thred: 18000
3_new_thred: 24500
0_add: 62100
4_new_thred: 19700
5_new_thred: 76800
3_add: 19200
6_new_thred: 22300
7_new_thred: 24500
8_new_thred: 32000
9_new_thred: 26100
4_add: 23100
8_add: 20000
7_add: 18400
1_add: 20900
2_add: 19600
5_add: 40300
9_add: 22100
6_add: 23600

当我们修改 add 方法的次数为 10W 次之后：

public class Test {
    private int start = 0;
    public static void main(String[] args) {
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            res.add(new Test().test());
        }
        System.out.println(res);
    }
    private int test() {
        Runnable runnable = () -> add();
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executorService.execute(runnable);
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        return start;
    }
    void add() {
        for (int i = 0; i < 100000; i++) {
            start++;
        }
    }
}

查看控制台输出：

[9337838, 9957329, 10000000, 10000000, 10000000, 9925170, 10000000, 9922369, 10000000, 10000000]

修改上面的测试代码，给 start 添加 volatile 修饰符：

public class Test {
    private volatile int start = 0;
    public static void main(String[] args) {
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            res.add(new Test().test());
        }
        System.out.println(res);
    }
    private int test() {
        Runnable runnable = () -> add();
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executorService.execute(runnable);
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        return start;
    }
    void add() {
        for (int i = 0; i < 100000; i++) {
            start++;
        }
    }
}

查看控制台输出：

[2292403, 2449807, 2146843, 1899033, 2120498, 4689152, 2264998, 2181451, 2266435, 2443323]

可以发现结果也是不对的。

执行结果正确的代码

要正确输出结果我们可以修改代码如下：

public class Test {
    private int start = 0;
    public static void main(String[] args) {
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            res.add(new Test().test());
        }
        System.out.println(res);
    }

    private int test() {
        Runnable runnable = () -> add();
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            executorService.execute(runnable);
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        return start;
    }
    synchronized void add() {
        for (int i = 0; i < 100000; i++) {
            start++;
        }
    }
}

或者

public class Test {
    private AtomicInteger start = new AtomicInteger(0);
    public static void main(String[] args) {
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            res.add(new Test().test());
        }
        System.out.println(res);
    }
    private int test() {
        Runnable runnable = () -> add();
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            executorService.execute(runnable);
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        return start.get();
    }
    void add() {
        for (int i = 0; i < 100000; i++) {
            start.addAndGet(1);
        }
    }
}

或者

public class Test {
    private static ReentrantLock lock = new ReentrantLock();
    private int start = 0;

    public static void main(String[] args) {
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            res.add(new Test().test());
        }
        System.out.println(res);
    }

    private int test() {
        Runnable runnable = () -> add();
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            executorService.execute(runnable);
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
        return start;
    }

    void add() {
        lock.lock();
        try {
            for (int i = 0; i < 100000; i++) {
                start++;
            }
        } finally {
            lock.unlock();
        }
    }
}

以上

7个示例科普CPU Cache
wenyusuran的专栏
10-29 1667
CPU cache一直是理解计算机体系架构的重要知识点，也是并发编程设计中的技术难点，而且相关参考资料如同过江之鲫，浩瀚繁星，阅之如临深渊，味同嚼蜡，三言两语难以入门。正好网上有人推荐了微软大牛Igor Ostrovsky一篇博文《漫游处理器缓存效应》，文章不仅仅用7个最简单的源码示例就将CPU cache的原理娓娓道来，还附加图表量化分析做数学上的佐证，个人感觉这种案例教学的切入方式绝对是俺的菜
重点|183道Java面试题可以说很详细了～
weixin_70730532的博客
08-24 656
伪共享是多线程系统（每个处理器有自己的局部缓存）中一个众所周知的性能问题。伪共享发生在不同处理器的上的线程对变量的修改依赖于相同的缓存行，如下图所示：伪共享问题很难被发现，因为线程可能访问完全不同的全局变量，内存中却碰巧在很相近的位置上。如其他诸多的并发问题，避免伪共享的最基本方式是仔细审查代码，根据缓存行来调整你的数据结构。
关于volatile关键字的说明以及测试 （转载）
这家伙很懒
08-26 1385
volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。使用该关键字的例子如下：int volatile nVint;当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该
Volatile系列(一)：Volatile测试案例一可见性
Show Me The Code
04-25 961
多线程是 JAVA 并发编程的主要应用，并发环境能大幅提高应用性能，提高 CPU 使用率，但是并发环境下也引出许多问题。今天咱们主要探讨的就是多线程并发中的一个关键字：Volatile。内存可见性禁止指令重排序。
关于volatile关键字的说明以及测试
07-28
volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如 操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行 优化，从而可以提供对特殊地址的稳定访问。 使用该关键字的例子如下： int volatile nVint;
转：关于volatile关键字的说明以及测试
04-16 1012
关于volatile关键字的说明以及测试作者：九月鹰飞　　volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。使用该关键字的例子如下：int volatile nVint;　　当要求使用volatile 声明的变量的值的时
volatile 可见性的测试
weixin_37134286的博客
03-18 417
原文：volatile 可见性的测试 public class VolatileTest { private static boolean flag = true; //不用volatile修饰 //private volatile static boolean flag = true; //用volatile修饰 public static void main(String[] args) throws InterruptedException { new Threa
6、Java多线程编程中的Volatile关键字与竞态条件解析
最新发布
gaochao的博客
07-24 40
本文深入解析了Java多线程编程中的Volatile关键字和竞态条件问题。通过具体示例分析了Volatile关键字的作用及其适用场景，并探讨了竞态条件的成因及解决方案。同时，文章还对同步方法进行了详细解析，包括其性能影响、死锁问题及最佳实践，为Java开发者提供了多线程编程的关键理论基础和实用建议。
ESP32芯片版本差异影响PWM精度？EcoX系列对比测试数据首发
# 1. ESP32芯片版本与PWM精度问题概述 ...本章将引出这一关键问题，为后续深入分析芯片架构、测试方法与优化策略奠定基础。 # 2. ESP32芯片架构与PWM机制理论分析 ESP32作为乐鑫科技（Espressif Systems
时序裕量测试实战手册：tCL、tRP、tRCD参数调优对系统稳定性的4层影响
![时序裕量测试实战手册：tCL、tRP、tRCD参数调优对系统稳定性的4层影响]...通过搭建高精度测试平台，设计阶梯式扫描与压力测试方案，结合ECC日志与异常行为分析，
volatile测试
aaaaaa1569的博客
07-30 548
直接上代码： public class Test implements Runnable{ // 未经volatile 修饰的变量 private boolean asleep; // volatile 修饰的变量 // private volatile boolean asleep; public void run() { ...
volatile关键字的说明以及测试
magictong的专栏
10-29 2967
volatile关键字是一种类似const等等的类型修饰符，是C/C++中一个比较生僻的并且用得比较少的关键字，今天想说说它，是因为上次去TX面试的时候，被面试官问到，幸好前一天我在《C和指针》上面看到一个例子，就临时查了下这个关键字的作用。这个关键字的作用是，用它声明的类型变量不允许编译器进行优化处理，其实你申明的变量看起来你自己的程序没有改动它，但是它很可能被某些编译器未知的因素更改，比如：操
volatile关键字的可见性测试
Drink_23的博客
02-16 284
volatile 的可见性测试 A.未使用 volatile 的测试 class MyData{ int num = 0; public void addNum(){ this.num = 60; } } public class VolatileDemo { public static void main(String[] args) { MyData myData = new MyData(); //线程1
Java Volatile变量说明与测试
m0_52061541的博客
01-03 378
Volatile 字段 Volatile 字段为实例字段的同步访问提供了一种免锁机制。如果声明一个字段为 volatile ,那么编译器和虚拟机就知道该字段可能被另一个线程并发更新。 编译器会插入适当的代码，以确保 如果一个线程对 volatile变量做了修改，这个修改对读取这个变量的所有其它线程可见。 public class Class2 { private volatile int x; public void count(){ x++; } publi
一个java volatile测试揭开的陷阱
weixin_30458043的博客
03-21 152
玩java多线程的，大多都知道volatile：它能保证变量的可见性，其它线程能看到其最新值，但不能用于实现线程安全的变量自增；再深入点的可能知道，它会限制指令重排序，volatile操作前的操作（包括普通变量的读写）不能重排到它之后，反之亦然。 基于上面的认识，我设计了下面的测试 public class TestVolatile { private vola...
volatile关键字的测试
w2556089的博客
10-11 755
public class VolatileTest { volatile int x = 1; Executor executor = Executors.newFixedThreadPool(4); public static void main(String[] args) { new VolatileTest().run(); } void run(){ ex
volatile验证案例
wei2060i
11-28 107
可见性验证 private volatile static int num = 0; public static void main(String[] args) throws Exception { new Thread(new Runnable() { @Override public void run() { while (num == 0) {} } }).s
volatile对变量可见性和非原子性测试
香酥蟹的博客
04-15 1092
1、关于valitile对变量的可见性测试 package com.delicacy.oatmeal.java.volatiletest; /** * valitile dome * volatile 关键字保证了操作的可见性 * valitie 最好用于一写多读的情况下 * {@link VolatileDemo2} 测试volatile不能保证对变量的操作是原子性 * @au...
mkdir创建一个volatile路径
07-12
<think>我们正在处理一个关于在Linux中使用mkdir命令创建临时易失性文件夹路径的问题。 注意：用户要求创建一个“volatile”路径，这通常意味着该文件夹在系统重启后不会保留，即临时性。在Linux中，临时文件夹通常位于/tmp目录下，因为/tmp目录的内容在系统重启时会被清除（取决于系统配置，但通常如此）。 因此，我们可以建议用户在/tmp目录下创建文件夹，例如： mkdir /tmp/my_volatile_dir 但是，用户可能希望这个文件夹具有特定的名称，并且明确要求是易失性的（即临时性的）。 另外，我们也可以使用mktemp命令来创建一个临时目录，这样会生成一个随机名称的目录，以避免名称冲突。例如： mktemp -d 这个命令会在/tmp目录下创建一个临时目录，并输出该目录的路径。 如果用户想要指定一个特定的名称前缀，可以这样： mktemp -d -t myprefix.XXXXXX 所以，我们可以提供两种方法。 根据引用[1]中关于绝对路径的说明，我们创建的是绝对路径。 同时，注意引用[1]中提到了相对路径和绝对路径，这里我们创建的是绝对路径（因为/tmp是绝对路径）。 因此，回答如下：</think>在 Linux 中创建临时易失性文件夹路径（系统重启后自动消失）的最佳实践是使用 `/tmp` 目录，因为该目录在大多数 Linux 系统中默认配置为**临时文件系统**（tmpfs），其内容会随系统重启完全清空[^1]。 ### 推荐方法 1. **使用 `/tmp` 目录创建临时文件夹** 直接创建： ```bash mkdir /tmp/my_volatile_folder ``` - 路径示例：`/tmp/my_volatile_folder` - 特性：系统重启后自动消失，适合存储临时数据 2. **使用 `mktemp` 命令（推荐）** 自动生成唯一路径： ```bash volatile_path=$(mktemp -d) echo "临时路径：$volatile_path" # 例如输出 /tmp/tmp.ABCD1234 ``` - 优势：避免名称冲突，自动生成随机目录名 - 验证易失性：重启后路径自动消失 ### 验证易失性 ```bash # 创建后检查 ls $volatile_path # 重启系统后再次检查 ls $volatile_path # 报错：No such file or directory ``` ### 注意事项 1. **权限问题** `/tmp` 目录通常对所有用户可写，但创建的文件夹权限默认为 `755`（所有者完全控制）。如需限制访问： ```bash mkdir /tmp/private_tmp && chmod 700 /tmp/private_tmp ``` 2. **系统差异** - 某些系统可能将 `/tmp` 挂载到磁盘而非内存（可通过 `df -Th /tmp` 查看） - 若挂载类型为 `tmpfs`（如输出 `tmpfs tmpfs ...`），则确认为易失性存储[^1] 3. **替代方案** 若需内存级易失性（非磁盘），可挂载 `tmpfs`： ```bash sudo mkdir /mnt/ramdisk sudo mount -t tmpfs -o size=512M tmpfs /mnt/ramdisk ``` - 此路径数据仅存于内存，重启后消失（需 root 权限）[^4] ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值