证明volatile 是线程可见的

最新推荐文章于 2025-09-19 19:39:57 发布

原创最新推荐文章于 2025-09-19 19:39:57 发布 · 490 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #jvm #面试

jdk 专栏收录该内容

3 篇文章

订阅专栏

本文深入探讨了Java中volatile关键字的作用，主要体现在线程可见性和禁止指令重排序。通过实例代码展示了未修饰和修饰后的变量在多线程环境中的行为差异，解释了线程如何从主内存和线程工作内存中读取变量值。同时，文章提到了即使没有volatile，通过延长代码执行时间也可能使线程重新从主内存获取变量，感知到变化。此外，还介绍了JMM内存模型对理解volatile的重要性。

1.介绍

Volatile关键字的作用主要有如下两个：
1.线程的可见性：当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。
2. 顺序一致性：禁止指令重排序。

本文主要介绍 java中 volatile 关键字是线程可见的，以前了解的是一个线程对 volatile 修饰的遍历修改之后，另一个线程再次获取这个变量的值的时候，就是修改之后的值了。如果变量没有 volatile 修饰，另一个线程就不会感知到便获。其实，这就需要了解JMM内存模型。

下面介绍我对 volatile 关键字的部分理解，在了解JMM 内存模型之后，明白线程是在哪里取值的，才能进一步理解 volatile 的意思。我认为，一个变量 Boolean flag 如果没有被 volatile 修饰，线程加载这个变量之后，会放入线程的内存中，在使用的时候，一直从线程内存中取值，对于主内存flag变量的变化，线程是不会感知的，也就是说，如果其他线程对flag进行操作，改变了他的值，那么这个线程也不会感知；但是也仅限于，线程内存flag值不会消失的情况，如果这个变量在线程内存中消失了，他再去主内存加载的时候，就是新的值，如果变量flag在线程内存中长时间不用，（这个时间也很短，大约几百毫秒的样子--我猜的，反正很短时间，因为线程内存也很小，对于不常用的变量就会丢弃，常用的就在里面存着方便下次使用）也可能会消失，线程再次取值的时候，只能去主内存取值，如果在取值之前，被另一个线程改变了，他取到的值就是改变后的值。

代码证明线程可见性

package com.example.demovalid;

public class test1 {

// 变量
    Boolean flag = true;

    public static void main(String[] args) throws InterruptedException {

        test1 test1 = new test1();

// 线程1 取变量的值
        Thread t1 = new Thread(() -> {

            System.out.println("这是--"+ Thread.currentThread() + "---" + test1.flag);


            // 这里死循环，是为了让线程1不断的取值，这里是取的线程内存的值，为了不让变量在线程内存中消失，不会去加载主内存的值
            while (true){

                if (!test1.flag){
                    System.out.println("这是11--"+ Thread.currentThread() + "---" + test1.flag);
                    break;
                }

            }
            System.out.println("这是222--"+ Thread.currentThread() + "---" + test1.flag);

        }, "t1");

// 线程2取变量的值，并对其修改
        Thread t2 = new Thread(() -> {
            try {
// 等1秒，为了让线程1启动起来
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 打印值
            System.out.println("这是--"+ Thread.currentThread() + "---" + test1.flag);
            System.out.println("t2" + System.currentTimeMillis());
// 对变量修改
            test1.flag= false;

        }, "t2");

// 线程1和2设置为守护线程，当主线程结束的时候，他们也结束
        t1.setDaemon(true);
        t2.setDaemon(true);

// 启动线程
        t1.start();
        t2.start();

// 主线程等待10秒，为了看线程1和2打印变量的值
        Thread.sleep(10000L);

        System.out.println("结束");

    }
}

上边是没有修饰的变量执行后打印的结果

这是--Thread[t1,5,main]---true
这是--Thread[t2,5,main]---true
t21671368338074
结束

从上面结果可以看出线程1没有感知到线程2对变量的修改，一直在循环中。

修饰之后的代码

package com.example.demovalid;

public class test1 {

// 修饰的变量
    volatile Boolean flag = true;

    public static void main(String[] args) throws InterruptedException {

        test1 test1 = new test1();

// 线程1 取变量的值
        Thread t1 = new Thread(() -> {

            System.out.println("这是--"+ Thread.currentThread() + "---" + test1.flag);


            // 这里死循环，是为了让线程1不断的取值，这里是取的线程内存的值，为了不让变量在线程内存中消失，不会去加载主内存的值
            while (true){

                if (!test1.flag){
                    System.out.println("这是11--"+ Thread.currentThread() + "---" + test1.flag);
                    break;
                }

            }
            System.out.println("这是222--"+ Thread.currentThread() + "---" + test1.flag);

        }, "t1");

// 线程2取变量的值，并对其修改
        Thread t2 = new Thread(() -> {
            try {
// 等1秒，为了让线程1启动起来
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 打印值
            System.out.println("这是--"+ Thread.currentThread() + "---" + test1.flag);
            System.out.println("t2" + System.currentTimeMillis());
// 对变量修改
            test1.flag= false;

        }, "t2");

// 线程1和2设置为守护线程，当主线程结束的时候，他们也结束
        t1.setDaemon(true);
        t2.setDaemon(true);

// 启动线程
        t1.start();
        t2.start();

// 主线程等待10秒，为了看线程1和2打印变量的值
        Thread.sleep(10000L);

        System.out.println("结束");

    }
}

执行结果

这是--Thread[t1,5,main]---true
这是--Thread[t2,5,main]---true
t21671368435004
这是11--Thread[t1,5,main]---false
这是222--Thread[t1,5,main]---false
结束

从上面可以看出线程2对变量改变后，线程1也能感知道。

3. 我们对案例1做一些变化，虽然没没有volatile修饰，但是我们在循环加一些代码，让代码执行时间长一些，等线程再次从线程内存中取值的时候，娶不到，就会去主内存中取值，这样也能感知到变量的变化。

package com.example.demovalid;

public class test3 {
    Boolean flag = true;
//    volatile Boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        test3 test1 = new test3();

        long currentTimeMillis = System.currentTimeMillis();

        Thread t1 = new Thread(() -> {

            System.out.println("这是--" + Thread.currentThread() + "---" + test1.flag);

            while (true) {

                try{
                // 这里抛异常，为了增加执行时间，延长下次从内存中去变量的值
                    int a = 1/0;
                }catch (Exception e){
// 这段打印是需要的，本人测试，去掉之后，还是不能跳出循环
                    System.out.println("出错以后");
                }

                if (!test1.flag) {
                    System.out.println("这是11--" + Thread.currentThread() + "---" + test1.flag);
                    break;
                }

            }
            System.out.println("这是222--" + Thread.currentThread() + "---" + test1.flag);

        }, "t1");

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("这是--" + Thread.currentThread() + "---" + test1.flag);
            System.out.println("t2" + System.currentTimeMillis());
            test1.flag = false;

        }, "t2");
        t1.setDaemon(true);
        t2.setDaemon(true);
        t1.start();
        t2.start();

        Thread.sleep(10000L);

        System.out.println("结束");

    }
}

执行结果

这是--Thread[t1,5,main]---true
出错以后
出错以后
.......
出错以后

这是--Thread[t2,5,main]---true
t21671368823608
出错以后
这是11--Thread[t1,5,main]---false
这是222--Thread[t1,5,main]---false

从执行结果看，在线程2改变了变量的值以后，线程1再次取值的时候，也感知到了变量的变化。这就是因为，线程1再次去线程内存取值的时候，发现线程内存变量消失了，只能去主内存取值，然而，主内存的变量，已经被线程2修改了，所以线程1取到的是改变后的值

下面是另一个测试代码

package com.example.demovalid;

public class test2 {

// 主要不同是，这个变量的静态修改的，其实与上面的结果是一样的
    static volatile Boolean flag = true;
//    volatile Boolean flag = true;
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {

            System.out.println("这是--"+ Thread.currentThread() + "---" + flag);

            while (true){

                if (!flag){
                    System.out.println("这是11--"+ Thread.currentThread() + "---" + flag);
                    break;
                }

            }
            System.out.println("这是222--"+ Thread.currentThread() + "---" + flag);

        }, "t1");

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("这是--"+ Thread.currentThread() + "---" + flag);
            System.out.println("t2" + System.currentTimeMillis());
            flag= false;

        }, "t2");
        t1.setDaemon(true);
        t2.setDaemon(true);
        t1.start();
        t2.start();

        Thread.sleep(10000L);

        System.out.println("结束");

    }
}

另外附上参考文章

有一个JMM内存模型的图： https://www.jb51.net/article/173207.htm