轻松理解volatile（从汇编角度），一看就会

最新推荐文章于 2024-06-24 10:11:54 发布

不蛋定

最新推荐文章于 2024-06-24 10:11:54 发布

阅读量1.4k

点赞数

分类专栏： java后台文章标签： volatile 多线程安全汇编角度内附代码

本文链接：https://blog.csdn.net/yc______/article/details/84071223

版权

java后台专栏收录该内容

9 篇文章 0 订阅

订阅专栏

回来填坑：下边说的作用只是volatile保证了goon的可见性，即如果有一个线程修改了共享变量，则会立即让其他线程都知道。如下例子，在主线程中修改了线程类的变量goon的值，每个线程都有属于自己的goon，所以那个goon被在主线程中赋值为false，那个线程就会结束。

补充一下：volatile还有一个作用就是保证有序性，在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。volatile 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。

每天进步多一点

假装下边是分割线

--------------------------------------------------------------------------------------------------------------

在网上也有很多关于volatile关键字的文章，看了很多，经过亲自测试，在此写下我的见解：

volatile关键字的作用：拒绝优化！

在java中，会将一些经常需要读写的成员拿到寄存器去进行运算，以此来加快运算速度。但是此操作并不是线程安全的，在多线程中，会有不同的线程对该成员进行操作，当该成员被拿到寄存器进行运算优化后，就不能时时刻刻保证与主内存的值同步，因此在多线程中操作时可能会产生错误。当一个成员被volatile关键字修饰时，就会拒绝优化：拒绝将该成员拿到寄存器去进行运算优化。以此来避免多线程不安全的问题。

举个很简单的例子：for(i = 0; i < 10; i++) {}

这个简单的操作，在没有加volatile关键字，i 被拿到寄存器进行运算优化：

假设i为一个局部变量，他的偏移量是-4，则 i 的首地址应该是edp[-4];

对应的汇编语言如下：

             mov ecx, edp[-4]
             loop:
           inc ecx
           cmp ecx, 10
           jl loop:

大概意思就是从首地址为-4的区域取出值，赋值给ecx，然后给ecx加一，用ecx和10作比较，如果小于10，就继续循环。

如果对变量i增加volitale关键字，则，将使用下面的汇编：
           loop:
           mov ecx, edp[-4]
           inc ecx
           mov edp[-4], ecx
           cmp ecx, 10
           jl loop

这段意思是说：从首地址未-4的区域取出值，赋值给ecx，给ecx加一，然后再将ecx的值赋值给原地址，即edp[-4]，然后使用ecx和10进行比较，如果小于10，则继续进入循环。

由此可见两者只有一句话不同，那就是有没有将改变后的值同步更新到源地址。未加volatile关键字的变量在寄存器中运算的时候使用的是ecx，而自己本身的值并没有变。加了volatile关键字的变量会在运算结束后，同步更新原来的值，然后再进行下一步操作。因为寄存器更注重运算速度，所以会省去同步值得步骤。由此可知：加了volatile关键字的变量，其运算速度会大打折扣。

下边举一个我做的小测试，很能说明问题：

编写一个线程类，在构造方法中启动该线程，使用一个Boolean类型的成员goon来控制线程的结束。此处goon未加volatile关键字：

package com.yc.test;
/*
 *@author yc
 *@time  2018/11/14
 */
public class TaskRunByThread implements Runnable{
    private static int id;
    private Boolean goon;

    public TaskRunByThread() {
        goon = true;
        new Thread(this,"[线程" + ++id + "]").start();
    }

    public void stopThread() {
        System.out.println("收到关闭线程的命令");
        goon = false;
    }

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "开始运行");
        while (goon) {
        }
        System.out.println("线程" + Thread.currentThread().getName() + "运行结束");
    }
}

编写一个简单的测试类，将上边的线程启动三次，然后每隔随机时间关闭一个线程。

package com.yc.test;

import java.util.Random;
/*
 *@author yc
 *@time  2018/11/14
 */
public class Test {
    public static void main(String[] args) {
        Random random = new Random();
        TaskRunByThread trbts[] = new TaskRunByThread[3];

        //注册并启动线程
        for (int i = 0; i < trbts.length; i++) {
            trbts[i] = new TaskRunByThread();
        }

        for (int i = 0; i < trbts.length; i++) {
            int num = random.nextInt(5000);
            System.out.println("时间间隔：" + num);
            try {
                Thread.sleep(num);
                trbts[i].stopThread();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

运行该测试类，