java中什么是指令重排序_【Java】聊聊多线程中的指令重排序

首页

专栏

java

文章详情

0

聊聊多线程中的指令重排序

小强大人发布于 1 月 28 日

什么是指令重排序？

Java内存模型允许编译器和处理器对指令进行重排序来提升运行性能，当然只会对那些不存在数据依赖的指令间进行重排序，不然的话会得到错误执行结果。然而，这种保证只对单线程有效，多线程环境下并不能保证这点，这就导致了多线程环境下，重排序后运行的结果并不是我们所预期的那样，这就是指令重排序。

下面举个栗子具体说明：

先来看个正常不会出问题的栗子：

public int add() {

int x = 1; //(1)

int y = 2; //(2)

int z = x + y; //(3)

return z;

}

上面的代码中,(1)和(2)没有依赖关系，它们之间可以重排序，(3)依赖了(1)和(2)，所以(3)不会被重排序到(1)或(2)之前，这个栗子中，(1)(2)即使发生了重排序，也不会影响程序运行结果。

再来看个可能会出现问题的栗子：

public class InstructionReorderDemo {

static int num = 0;

static boolean ready = false;

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

Thread readThread = new Thread(() -> {

if (ready) { //(1)

System.out.println(num + num); //(2)

}

});

Thread writeThread = new Thread(() -> {

num = 2; //(3)

ready = true; //(4)

});

readThread.start();

writeThread.start();

readThread.join();

writeThread.join();

System.out.println("main thread exit.");

}

}

这个栗子中，由于(1)(2)(3)(4)之间都没有数据依赖，可能会有同学有疑问，(1)不是依赖了(4)吗，(2)不是依赖了(3)吗？别忘了，这4条指令放在单线程下才能保证这点，就是说下面的代码才会产生上述依赖：

int num;

boolean ready;

public void calculate {

num = 2;

ready = true;

if (ready) {

System.out.println(num + num);

}

}

这里是多个线程分别访问共享变量ready和num，且它们都没有用volatile修饰，两个线程并发运行，编译器/处理器可能会对(3)(4)进行重排序，因为它们之间没有数据依赖。但这时，如果按如下时间线运行，就会出现运行结果是0，而不是4。

readThread

writeThread

ready = true //(4)

if(ready) //(1)

num + num //(2)

num = 2 //(3)

如何避免指令重排序？

方法很简单，把上述程序中的ready变量用volatile修饰即可。volatile关键字不仅保证了内存可见性，还有内存屏障的作用，在JVM底层是用Lock前缀的指令实现的。它保证了在写volatile变量指令时，在它之前的指令不会被重排序到它之后，在这个栗子中就是num = 2不会在ready = true之后执行；在读volatile变量时，在它之后的指令不会被重排序到它之前，在这个栗子中就是num + num不会放在if (ready)之前执行。

参考资料：

《Java并发编程之美》

java

阅读 43发布于 1 月 28 日

赞收藏

分享

本作品系原创，采用《署名-非商业性使用-禁止演绎 4.0 国际》许可协议

小强大人

9声望

1粉丝

关注作者

0 条评论

得票时间

提交评论

小强大人

9声望

1粉丝

关注作者

宣传栏

目录

▲

什么是指令重排序？

Java内存模型允许编译器和处理器对指令进行重排序来提升运行性能，当然只会对那些不存在数据依赖的指令间进行重排序，不然的话会得到错误执行结果。然而，这种保证只对单线程有效，多线程环境下并不能保证这点，这就导致了多线程环境下，重排序后运行的结果并不是我们所预期的那样，这就是指令重排序。

下面举个栗子具体说明：

先来看个正常不会出问题的栗子：

public int add() {

int x = 1; //(1)

int y = 2; //(2)

int z = x + y; //(3)

return z;

}

上面的代码中,(1)和(2)没有依赖关系，它们之间可以重排序，(3)依赖了(1)和(2)，所以(3)不会被重排序到(1)或(2)之前，这个栗子中，(1)(2)即使发生了重排序，也不会影响程序运行结果。

再来看个可能会出现问题的栗子：

public class InstructionReorderDemo {

static int num = 0;

static boolean ready = false;

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

Thread readThread = new Thread(() -> {

if (ready) { //(1)

System.out.println(num + num); //(2)

}

});

Thread writeThread = new Thread(() -> {

num = 2; //(3)

ready = true; //(4)

});

readThread.start();

writeThread.start();

readThread.join();

writeThread.join();

System.out.println("main thread exit.");

}

}

这个栗子中，由于(1)(2)(3)(4)之间都没有数据依赖，可能会有同学有疑问，(1)不是依赖了(4)吗，(2)不是依赖了(3)吗？别忘了，这4条指令放在单线程下才能保证这点，就是说下面的代码才会产生上述依赖：

int num;

boolean ready;

public void calculate {

num = 2;

ready = true;

if (ready) {

System.out.println(num + num);

}

}

这里是多个线程分别访问共享变量ready和num，且它们都没有用volatile修饰，两个线程并发运行，编译器/处理器可能会对(3)(4)进行重排序，因为它们之间没有数据依赖。但这时，如果按如下时间线运行，就会出现运行结果是0，而不是4。

readThread

writeThread

ready = true //(4)

if(ready) //(1)

num + num //(2)

num = 2 //(3)

如何避免指令重排序？

方法很简单，把上述程序中的ready变量用volatile修饰即可。volatile关键字不仅保证了内存可见性，还有内存屏障的作用，在JVM底层是用Lock前缀的指令实现的。它保证了在写volatile变量指令时，在它之前的指令不会被重排序到它之后，在这个栗子中就是num = 2不会在ready = true之后执行；在读volatile变量时，在它之后的指令不会被重排序到它之前，在这个栗子中就是num + num不会放在if (ready)之前执行。

参考资料：

《Java并发编程之美》