Java~重排序给多线程带来的影响, 包括volatile域和final域的重排序规则

蜂信物联FastBee平台https://gitee.com/beecue/fastbee

阿里资料开源项目https://gitee.com/vip204888

百度低代码前端框架https://gitee.com/baidu/amis

OpenHarmony开源项目https://gitcode.com/openharmony

仓颉编程语言开放项目https://gitcode.com/Cangjie
i = 1; //1

key = true; //2

}

public synchronized int read() {

int a = 0;

if (key) { //3

a = i * i; //4

}

return a;

}

}

• 在同步程序中, 这俩个write和read就成了同步方法, 也就是他们会串行执行, 这样即使在一个方法内发生了重排序, 对另一个线程来说是没有影响的

volatile域的重排序规则

---

• volatile修饰的变量只是保证内存可见性, 也就是只是说你这个线程读到的数据一定是从内存中读出来的. 但是他并不是原子的, 如果你在多线程环境下进行运算, 依旧不是安全的.

• 所以volatile域就会有重排序规则

• 上图中, 我们可以发现

1. 当第二个操作是volatile写时，不管第一个操作是什么，都不能重排序。这个规则确保volatile写之前的操作不会被编译器重排序到volatile写之后。

2. 当第一个操作是volatile读时，不管第二个操作是什么，都不能重排序。这个规则确保volatile读之后的操作不会被编译器重排序到volatile读之前。

3. 当第一个操作是volatile写，第二个操作是volatile读时，不能重排序。

• 总而言之就是在单个volatile写之前和读之后是绝对不让重排序的, 俩个操作都是volatile操作 ,是更是不让重排序的,

• 写之前

• 读之后

final域的重排序规则

---

• 对于final域，编译器和处理器要遵守两个重排序规则。

1. 在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用 变量，这两个操作之间不能重排序。

2. 初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操作之间不能 重排序。

class FinalExample {

int i;

final int j;

static FinalExample obj;

public FinalExample() {

this.i = 1; //写普通域

this.j = 2; //写final域

}

public static void write() { //A线程执行

obj = new FinalExample();

}

public static void read() { //B线程执行

FinalExample object = obj; //读取对象引用

int a = object.i; //读取普通域

int b = object.j; //读取final域

}

}

写final域的重排序规则

• 写final域的重排序规则禁止把final域的写重排序到构造函数之外。这个规则的实现包含下面2个方面。

1. JMM禁止编译器把final域的写重排序到构造函数之外。

2. 编译器会在final域的写之后，构造函数return之前,插入一个StoreStore屏障。这个屏障禁止处理器把final域的写重排序到构造函数之外。

• 现在让我们分析writer()方法。writer()方法只包含一行代码：finalExample=new FinalExample()。这行代码包含两个步骤，如下。

• 1）构造一个FinalExample类型的对象。

• 2）把这个对象的引用赋值给引用变量obj

• 上图我们发现写普通域的操作被编译器重排序到了构造函数之外，读线程B错误地读取了 普通变量i初始化之前的值。而写final域的操作，被写final域的重排序规则“限定”在了构造函数 之内，读线程B正确地读取了final变量初始化之后的值。

• 写final域的重排序规则可以确保：在对象引用为任意线程可见之前，对象的final域已经被 正确初始化过了，而普通域不具有这个保障。

读final域的重排序规则

• 读final域的重排序规则是，在一个线程中，初次读对象引用与初次读该对象包含的final域, 这俩个操作是不让重排序的

• reader()方法包含3个操作。

• 1· 初次读引用变量obj。

• 2· 初次读引用变量obj指向对象的普通域j。

• 3· 初次读引用变量obj指向对象的final域i。

• 读对象的普通域的操作被处理器重排序到读对象引用之前。读普通域时，该 域还没有被写线程A写入，这是一个错误的读取操作。而读final域的重排序规则会把读对象 final域的操作“限定”在读对象引用之后，此时该final域已经被A线程初始化过了，这是一个正 确的读取操作.

• 读final域的重排序规则可以确保：在读一个对象的final域之前，一定会先读包含这个final 域的对象的引用。如果该引用不为null，那么引用对象的final域一定已经被初始化过了。

如果final域修饰的是引用类型

class FinalReferenceExample {

final int[] array;

static FinalReferenceExample obj;

private FinalReferenceExample() {

array = new int[1];

array[0] = 1;

}

public static void writeOne() {

obj = new FinalReferenceExample();

}

public static void writeTwo() {

obj.array[0] = 2;

}

public static void read() {

if (obj != null) {

System.out.println(obj.array[0]);

}

}

}

• final域为一个引用类型，它引用一个int型的数组对象。对于引用类型，写final域的重 排序规则对编译器和处理器增加了如下约束：在构造函数内对一个final引用的对象的初始化, 和将初始化后的这个对象的地址赋值给final域修饰的引用，这两个操作之间不能重排序。
  
• 就如上图所示, 我们前面说到写final域一定是在构造函数结束前执行的, 并且是不可以重排序的, 在这里包括初始化final引用的这个对象, 和将这个对象赋值给array这个引用, 包括下面给array[0]的写入, 都是不可以重排序的.

最后

这份清华大牛整理的进大厂必备的redis视频、面试题和技术文档

祝大家早日进入大厂，拿到满意的薪资和职级~~~加油！！

感谢大家的支持！！

)

• 就如上图所示, 我们前面说到写final域一定是在构造函数结束前执行的, 并且是不可以重排序的, 在这里包括初始化final引用的这个对象, 和将这个对象赋值给array这个引用, 包括下面给array[0]的写入, 都是不可以重排序的.

最后

这份清华大牛整理的进大厂必备的redis视频、面试题和技术文档

祝大家早日进入大厂，拿到满意的薪资和职级~~~加油！！

感谢大家的支持！！

[外链图片转存中…(img-DF5SIMS8-1725154531469)]