Java关键字-volatile

最新推荐文章于 2024-10-11 17:32:18 发布

老王的进阶之路

最新推荐文章于 2024-10-11 17:32:18 发布

阅读量1.2k

点赞数 22

分类专栏： volatile 文章标签： java

本文链接：https://blog.csdn.net/wzhy2016/article/details/135955576

版权

volatile 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

volatile概述

volatile是Java提供的一种轻量级的同步机制，在并发编程中，它也扮演着比较重要的角色。同synchronized相比(synchronized通常称为重量级锁)，volatile更轻量级，使用synchronized会带来的庞大开销。

volatile 是 Java 中的关键字，是一个变量修饰符，被用来修饰会被不同线程访问和修改的变量。（保证了可见性，但保证原子性）

volatile的作用

1.可见性

可见性是指多个线程共同访问一个变量，其中一个线程修改了该变量的值，其他线程立即见到修改后的值。


public class volatileDemo1 {
    // 定义一个标志
    static boolean flag = true;
    public static void main(String[] args) {
        // 定义两个线程 t1 t2
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t---------------come in");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception exp) {
                exp.printStackTrace();
            }
            flag = false;
            System.out.println("-------flag(1)="+flag);
        },"t1").start();
        System.out.println("-------flag(2)="+flag);
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t--------------come in");
            while (flag) {

            }
            System.out.println(Thread.currentThread().getName()+"\t flag=false,程序停止...............");
        },"t2").start();
    }
}

上面的例子，模拟多线程环境中，t1线程对flag共享变量修改的值能否在t2中见到，即是否可以输出“flag=false,程序停止…”这句好。

这个结论会让人有些疑惑，可以理解，单线程模型里，因为先发生happens-before，自然是可以正确保证输出的，在多线程模型中，是没法做这种保证的。因为对于共享变量flag来说，线程t1的修改，对于线程t2来说是不可见的，也就是说t2可能无法观测到t1对共享变量的修改。

所谓可见性，是指当一个线程修改了某个共享变量的值，其他线程是否能够收立即得知该变更，JMM规定了所有变量都存储在主内存中。很显然上面的例子没有做到内存可见性。

public class volatileDemo2 {
    // 定义一个标志
    public static volatile boolean flag = true;
    public static void main(String[] args) {
        // 定义两个线程 t1 t2
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t---------------come in");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception exp) {
                exp.printStackTrace();
            }
            flag = false;
            System.out.println("-------flag(1)="+flag);
        },"t1").start();
        System.out.println("-------flag(2)="+flag);
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t--------------come in");
            while (flag) {

            }
            System.out.println(Thread.currentThread().getName()+"\t flag=false,程序停止...............");
        },"t2").start();
    }
}

若不加volatile修饰为何t2看不到t1线程修改为false的flag值？

t1线程修改了flag之后没有将其刷新回主内存，所以t2线程获取不到。
主线程将flag刷新到了主内存，但是t2一直读取的是自己的工作内存中的flag值，没有去主内存中更新获取flag最新的值。

使用volatile修饰共享变量后，被volatile修饰的变量有以下几个特点：

线程中读取时候，每次读取都会从主内存读取共享变量最新的值，然后将其复制到工作内存；
线程中修改了工作内存中的变量副本，修改之后会立即刷新到主内存中；

2.原子性

volatile只保证单次读/写操作的原子性，对于多步操作，volatile不能保证其原子性，如以下案例：

public class VolatileCounter {
    private volatile int count = 0;

    public void inc() {
        count++;
    }

    public void dec() {
        count--;
    }

    public int get() {
        return count ;
    }
}

public class VolatileTest {
    public static void main(String[] args) {
        while (true) {
            VolatileCounter counter = new VolatileCounter();
            Thread thread1 = new Thread(()->{
                for (int i=0;i<50;i++) {
                    counter.inc();
                }
            },"t1");

            Thread thread2 = new Thread(()->{
                for (int i=0;i<50;i++) {
                    counter.dec();
                }
            },"t2");

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

            try {
                thread1.join();
                thread2.join();
            } catch (Exception exp) {
                exp.printStackTrace();
            }

            System.out.println("counter = " + counter.get());
        }
    }
}

从运行结果来看，绝大部分情况下输出结果为count=0，但也有部分其他结果，由此可见，对于count++和count–这两个操作并具有原子性。
这是因为count++ 是一个复合操作，包括三个部分：

读取count的值
对count加1
将count的值写回内存

volatile对这三步操作是无法保证原子性的，所以会出现以上结果。

3.有序性

在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，但是会影响到多线程并发执行的正确性。
volatile 关键字可以禁止指令重新排序，可以保证一定的有序性。
volatile 修饰的变量的有序性有两层含义：

所有在 volatile 修饰的变量写操作之前的写操作，将会对随后该 volatile 修饰的变量读操作之后的语句可见。
禁止 JVM 重排序：volatile 修饰的变量的读写指令不能和其前后的任何指令重排序，其前后的指令可能会被重排序。

3.1 happen-before

happen-before 关系是用来判断是否存在数据竞争、线程是否安全的主要依据，也是指令重排序的依据，保证了多线程下的可见性。
volatile 修饰的变量在读写时会建立 happen-before 关系。
如下面的测试类：

public class VolatileOrder {
    int i = 0;
    volatile boolean flag = false;

    public void write() {
        i = 1; // 步骤 1
        flag = true; // 步骤 2
    }

    public void get() {
        if (flag) { // 步骤 3
            System.out.println("i = " + i); // 步骤 4

        }
    }
}

上面的代码依据 happen-before 原则（关于 happen-before 原则可自行搜索）会建立如下的关系：

根据 happen-before 单线程顺序原则会有：步骤 1 happen-before 步骤 2、步骤 3 happen-before 步骤 4；
根据 happen-before 的 volatile 原则会有：步骤 2 happen-before 步骤 3；
根据 happen-before 的传递性原则会有：步骤 1 happen-before 步骤 4；

所以步骤 1 对于步骤 4 是可见的，即变量 i 在多个线程中具有可见性。
这也解释了 volatile 有序性的第一层含义：所有在 volatile 修饰的变量写操作之前的写操作，将会对随后该 volatile 修饰的变量读操作之后的语句可见。
利用这个特性可以优化变量在线程间的可见性，不需要对每个变量都用 volatile 修饰，只需要用 volatile 修饰一部分变量即可保证其它变量在多线程间也具有可见性。

3.2 禁止 JVM 重排序

对于上述代码，如果变量 flag 没有使用 volatile 修饰，那么步骤 1 和步骤 2 就有可能被 JVM 重排序，就无法得到上述的 happen-before 关系，所以 volatile 修饰的变量禁止 JVM 重排序。
如下代码所示：

public class VolatileOrder {

    int a, b, c;
    volatile int d;

    void write() {
        a = 1;
        b = 2;
        c = 3;
        d = 4;
    }

    void read() {
        int D = d;
        int A = a;
        int B = b;
        int C = c;
    }
}