一分钟让你理解多线程特性之一的可见性

Vivien_o.O

已于 2022-01-21 21:56:54 修改

阅读量364

点赞数 2

分类专栏： JAVA 文章标签： java 开发语言后端

于 2022-01-21 21:56:03 首次发布

本文链接：https://blog.csdn.net/qq_45795744/article/details/122629754

版权

JAVA 专栏收录该内容

41 篇文章 2 订阅

订阅专栏

可见性是什么？

定义：指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

首先看一段简单的代码：

package com.dyit.volatiletest;

/**
 * @ClassName: VolatileDemo
 * @Author
 * @Date 2022/1/21
 */

  //
public class VolatileDemo {
    public static   boolean f = false;

    public static class A extends Thread {

        @Override
        public void run() {
            while (true) {// f如果为true，执行循环
                //如果f为true则进行输出
                if (f) {
                    System.out.println(getName() + "运行: " + f);
                    break;
                }
            }
        }

    }

    public static class B extends Thread {
        @Override
        public void run() {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            f = true;
            System.out.println(getName() + "运行: " + f);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new A();
        t1.setName("A");
        Thread t2 = new B();
        t2.setName("B");
        t1.start();
        t2.start();
    }
}

你觉得A线程会运行吗，在B线程已经修改了f的前提下。

结果：
在这里插入图片描述
在B线程中把f变为true以后,A线程依旧不输出。

这又是为什么呢？明明f的值已经更新为什么A线程依旧不输出呢？

原因：
线程在运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值.在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了

这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

在这里插入图片描述

注意：在上面说过在修改完值后会在某一个时刻将副本的值写回内存中。那么我们如果在A线程中输出一下f ，会导致什么结果呢？

package com.dyit.volatiletest;

/**
 * @ClassName: VolatileDemo
 * @Author
 * @Date 2022/1/21
 */

  //
public class VolatileDemo {
    public static   boolean f = false;

    public static class A extends Thread {

        @Override
        public void run() {
            while (true) {// f如果为true，执行循环
                //如果f为true则进行输出
                if (f) {
                    System.out.println(getName() + "运行: " + f);
                    break;
                }
                
                //添加一个输出语句.
                System.out.println(f);
            }
        }

    }

    public static class B extends Thread {
        @Override
        public void run() {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            f = true;
            System.out.println(getName() + "运行: " + f);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new A();
        t1.setName("A");
        Thread t2 = new B();
        t2.setName("B");
        t1.start();
        t2.start();
    }
}

结果：
在这里插入图片描述
你会发现在A修改了值以后B线程中的f变为了true。这就是因为一个小小的输出语句，导致下次查看 f 时，是从内存中读取，所以变为了true；

这并不是我们要讨论的重点

我们要看的时如何避免上面的情况发生，让线程变得安全，每次读取都是从主存进行读取，各个任务之间共享变量呢？

有两种解决方案：

添加synchronized关键字或者实现Lock，实现共享锁，每次只能一个线程进行访问，synchronized和Lock可以保证可见性。
声明变量为volatile

我们主要看第二种方案

加上volatile的代码如下：

public class VolatileDemo {
    public static volatile   boolean f = false;

    public static class A extends Thread {

        @Override
        public void run() {
            while (true) {// f如果为true，执行循环
                //如果f为true则进行输出
                if (f) {
                    System.out.println(getName() + "运行: " + f);
                    break;
                }

                //添加一个输出语句.
                System.out.println(f);
            }
        }

    }

    public static class B extends Thread {
        @Override
        public void run() {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            f = true;
            System.out.println(getName() + "运行: " + f);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new A();
        t1.setName("A");
        Thread t2 = new B();
        t2.setName("B");
        t1.start();
        t2.start();
    }
}