JVM系列之：关于即时编译器的其他一些优化手段
本文为《深入学习 JVM 系列》第二十篇文章
在前面两篇文章讲述了即时编译器的两种特殊优化技术：方法内联和逃逸分析，其中基于逃逸分析结果又有三种优化方式：同步消除、栈上分配以及标量替换。
所以本文的核心主旨是：学习即时编译器的优化手段，未来自己写代码时，在保证可读性的前提下，尽量减少编译器的工作量。
接下来我们就学习一下编译器的优化手段，不会介绍全部，仅仅介绍一些日常写代码遇得见的情况，文章将伴随大量代码案例，旨在提升代码水平。
说点题外话，在学习优化手段时，突然想到这些是即时编译器的优化措施，那如果没有触发即时编译，那不就没意义了吗？而且在讲述方法内联和逃逸分析时，一直都是用大循环来触发即时编译，如果只是单次代码调用，那不就没戏了吗？查了一下资料，最终还是想通了，实际应用中，我们写的代码不像文章中的测试代码，那么简单，实际代码是属于系统中的一部分，而系统开发出来就是要运行的，只要系统运行时间够长，程序中绝大部份方法都会触发即时编译，被编译成本地代码。所以还是好好学习一下文章中介绍的优化手段吧。
字段读取优化
首先我们需要了解 JMM（Java内存模型），关于这些知识推荐阅读本文，我们这里引入以下几个概念：
-
线程之间的共享变量存储在主内存（Main Memory）中；
-
每个线程都有一个私有的本地内存（Local Memory），本地内存是JMM的一个抽象概念，并不真实存在，它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。本地内存中存储了该线程以读/写共享变量的拷贝副本。
如下图所示：
对象的实例字段和静态字段存在堆中，属于线程共享的数据。
即时编译器会优化实例字段以及静态字段访问，以减少总的内存访问数目。具体来说，它将沿着控制流，缓存各个字段存储节点将要存储的值，或者字段读取节点所得到的值。
当即时编译器遇到对同一字段的读取节点时，如果缓存值还没有失效，那么它会将读取节点替换为该缓存值。这里说明一下缓存值为何会失效，比如说多个线程操作同一个字段，进行读写操作，如果该字段被 volatile 修饰，那么线程独自拥有的工作内存中数据会被清除掉，需要从主内存重新加载。更多细节推荐阅读我之前的文章《深入了解volatile关键字》。
下面我们来看一下缓存字段读取节点的情况。
static int bar(Foo o, int x) {
int y = o.a + x;
return o.a + y;
}
在上面这段代码中，实例字段 Foo.a 将被读取两次。即时编译器会将第一次读取的值缓存起来，并且替换第二次字段读取操作，以节省一次内存访问。这让我联想到日常开发中对于 getter 方法的使用，如果大于两次通过 getter 方法访问同一个字段，则最好定义一个变量。
static int bar(Foo o, int x) {
int t = o.a;
int y = t + x;
return t + y;
}
如果字段读取节点被替换成一个常量，那么它将进一步触发更多优化。
static int bar(Foo o, int x) {
o.a = 1;
if (o.a >= 0)
return x;
else
return -x;
}
上述代码很简单，bar 方法经过编译器优化后，可以直接替换为具体结果 true。所以开发人员完全可以避免让编译器费事，写代码的时候检查一下代码逻辑。
小结一下：
被 volatile 修饰的字段，编译器会在字段访问前后插入内存屏障节点，保证了不同线程对这个变量进行操作时的可见性。同样这也意味着该操作会阻止编译器的字段读取优化。同理，加锁、解锁操作也会阻止此种优化手段。
字段存储优化
除了字段读取优化之外，即时编译器还将消除冗余的存储节点。如果一个字段先后被存储了两次，而且这两次存储之间没有对第一次存储内容的读取，那么即时编译器可以将第一个字段存储给消除掉。
class Foo {
int a = 0;
void bar() {
a = 1;
a = 2;
}
}
不会有人这样写代码吧，上述代码比较简单，编译器会进行冗余存储消除优化。
class Foo {
int a = 0;
void bar() {
a = 1;
int t = a;
a = t + 2;
}
}
// 进行复写传播优化为
class Foo {
int a = 0;
void bar() {
a = 1;
int a = a;
a = a + 2;
}
}
// 进一步优化为
class Foo {
int a = 0;
void bar() {
a = 3;
}
}
上述代码除了用到冗余存储消除，还有复写传播，没有必要使用一个额外的变量 t，它与变量 a是完全相等的。
因为 volatile 除了保证了变量的可见性，还禁止指令重排序，那么即时编译器也不能将冗余的存储操作消除掉。
虽然重复给同一个变量赋值多次看起来很蠢，但实际上并不少见，比如说两个存储之间隔着许多其他代码，或者因为方法内联的缘故，将两个存储操作（如构造器中字段的初始化以及随后的更新）纳入同一个编译单元里。
死代码消除
除了字段存储优化之外，局部变量的死存储（dead store）同样也涉及了冗余存储。这是死代码消除（dead code eliminiation）的一种。不过，由于 Sea-of-Nodes IR 的特性，死存储的优化无须额外代价。
int bar(int x, int y) {
int t = x*y;
t = x+y;
return t;
}
除了消除冗余存储，甚至变量 t 也没必要声明，所以优化为：
int bar(int x, int y) {
return x+y;
}
死存储还有一种变体，即在部分程序路径上有冗余存储。
int bar(boolean f, int x, int y) {
int t = x*y;
if (f)
t = x+y;
return t;
}
上述代码中，如果布尔型变量为 true，那么变量 t会被赋值两次。如果优化之后，代码可以改为：
int bar(boolean f, int x, int y) {
if (f)
return x+y;
return x*y;
}
另一种死代码消除则是不可达分支消除。不可达分支就是任何程序路径都不可到达的分支。在即时编译过程中，我们经常因为方法内联、常量传播以及基于 profile 的优化等，生成许多不可达分支。
int bar(int x) {
if (getFlag())
return x;
else
return -x;
}
比如上述代码，如果 getFlag 方法一直返回 false，那么就会一直走 else 分支，那么就会被优化为：
int bar(int x) {
return -x;
}
我们来看一种特殊情况，编译器无法进行优化。
int bar(int x, int y) {
int t = x/y;
t = x+y;
return t;
}
上述代码无法优化为直接返回 x+y，因为 x/y 有除0异常，所以编译器没法优化掉这个除法。
公共子表达式消除
公共子表达式消除是一项非常经典的、普遍应用于各种编译器的优化技术，该项技术比较简单。如果一个表达式重复出现多次，且表达式中的变量值都没有发生改变，那么该表达式可称为公共子表达式。
public static void main(String[] args) {
int a = 2, b = 3, c = 4;
int d = (c * b) * 12 + a + (a + b * c);
}
javac 编译器并不会对上述代码做任何优化，我们查看字节码文件内容如下：
stack=4, locals=5, args_size=1
0: iconst_2
1: istore_1
2: iconst_3
3: istore_2
4: iconst_4
5: istore_3
6: iload_3
7: iload_2
8: imul //c*b
9: bipush 12 //将常量12推送至栈顶
11: imul //(c * b) * 12
12: iload_1
13: iadd //(c * b) * 12 + a
14: iload_1
15: iload_2
16: iload_3
17: imul //b*c
18: iadd //a+b*c
19: iadd //(c * b) * 12 + a + (a + b * c)
20: istore 4
22: return
这些指令都比较简单，不懂的指令可以参考本文。
编译器检测到代码中 c*b 和 b*c 是一样的表达式，而且在计算期间 b 与 c 未发生改变。因此上述代码变为：
int temp = b * c;
int d = temp * 12 + a + (a + temp);
这时候，即时编译器还会进行另一种优化——代数化简（数学中对代数方程进行简化），继续优化为：
int temp = b * c;
int d = temp * 13 + 2 * a;
不过话说回来，平时写代码时应该不会这样写，也就不必让编译器优化了。
在代码中，循环都扮演着非常重要的角色。为了提升循环的运行效率，即时编译器也提供了不少面向循环的编译优化方式，如循环无关代码外提，循环展开等。
循环无关代码外提
所谓的循环无关代码（Loop-invariant Code），指的是循环中值不变的表达式。如果能够在不改变程序语义的情况下，将这些循环无关代码提出循环之外，那么程序便可以避免重复执行这些表达式，从而达到性能提升的效果。
public static int foo(int x, int y, int[] a) {
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum += x * y + a[i];
}
return sum;
}
对应字节码为：
public static int foo(int, int, int[]);
descriptor: (II[I)I
flags: (0x0009) ACC_PUBLIC, ACC_STATIC
Code:
stack=4, locals=5, args_size=3
0: iconst_0
1: istore_3
2: iconst_0
3: istore 4
//循环开始
5: iload 4
7: aload_2
8: arraylength //获取数组长度，压入栈顶
9: if_icmpge 29
12: iload_3
13: iload_0
14: iload_1
15: imul
16: aload_2
17: iload 4
19: iaload
20: iadd
21: iadd
22: istore_3
23: iinc 4, 1
26: goto 5
//循环结束
29: iload_3
30: ireturn
上述代码中，循环体中的表达式 x*y，以及循环判断条件中的 a.length 均属于循环不变代码。前者是一个整数乘法运算，而后者则是内存访问操作，读取数组对象a的长度。（数组的长度存放于数组对象的对象头中，可通过 arraylength 指令来访问。）
首先表达式 x*y 又属于公共子表达式，按理来说应该声明一个变量来消除它，为了减少计算量，把变量放在循环外声明。
然后来处理循环条件中的 a.length，每次循环时会去访问一下内存，按理说将其单独定义为一个变量更好，但是我们在写循环代码时早已习惯这种方式，所以我个人认为不必强制要求代码中声明变量来存储 a.length，可读性更高一些。
综上，我们得到如下代码：
public static int foo(int x, int y, int[] a) {
int sum = 0;
int temp = x*y;
for (int i = 0; i < a.length; i++) {
sum += temp + a[i];
}
return sum;
}
我们看一下下面这段代码，思考一下 Object 对象声明的位置应该在哪呢？是在循环体内，还是循环体外。
Object o;
for (int i = 0; i < 2000; i++) {
o = new Object();
o.hashCode();
}
上述格式是我常写的格式，把变量放在循环外声明，自以为循环外申明变量内存占用会小一些。
但关于变量声明在循环体内还是循环体外一直存在争论，后来学习了字节码后，再结合网友们的讨论，得出如下结论：变量声明优先考虑在循环体内定义。
循环展开
编译器还有一项非常重要的循环优化是循环展开（Loop Unrolling）。它指的是在循环体中重复多次循环迭代，并减少循环次数的编译优化。
int foo(int[] a) {
int sum = 0;
for (int i = 0; i < 64; i++) {
sum += (i % 2 == 0) ? a[i] : -a[i];
}
return sum;
}
上面的代码经过循环展开之后将形成下面的代码：
int foo(int[] a) {
int sum = 0;
for (int i = 0; i < 64; i += 2) {
sum += a[i];
sum += -a[i + 1];
}
return sum;
}
在 C2 中，只有计数循环（Counted Loop）才能被展开。所谓的计数循环需要满足如下四个条件：
- 维护一个循环计数器，并且基于计数器的循环出口只有一个（但可以有基于其他判断条件的出口，比如说循环体内的if-break语句）。
- 循环计数器的类型为 int、short 或者 char（既不能是 byte、long，更不能是 float 或者 double）。
- 每个迭代循环计数器的增量为常数。
- 循环计数器的上限（增量为正数）或下限（增量为负数）是循环无关的数值。
循环展开有一种特殊情况，那便是完全展开（Full Unroll）。当循环的次数是固定值而且非常小时，循环语句会被替换为普通的赋值语句。
int foo(int[] a) {
int sum = 0;
for (int i = 0; i < 4; i++) {
sum += a[i];
}
return sum;
}
//替换为
int foo(int[] a) {
int sum = 0;
sum += a[0];
sum += a[1];
sum += a[2];
sum += a[3];
return sum;
}
关于这种优化手段，个人觉得仅做了解即可，日常开发没必要在乎这些，代码可读性不怎么高。
循环判断外提
循环判断外提指的是将循环中的 if 语句外提至循环之前，并且在该 if 语句的两个分支中分别放置一份循环代码。
int foo(int[] a) {
int sum = 0;
for (int i = 0; i < a.length; i++) {
if (a.length > 4) {
sum += a[i];
}else {
sum += 2* a[i] - 1;
}
}
return sum;
}
优化后变为：
int foo(int[] a) {
int sum = 0;
if (a.length > 4) {
for (int i = 0; i < a.length; i++) {
sum += a[i];
}
} else {
for (int i = 0; i < a.length; i++) {
sum += 2* a[i] -1;
}
}
return sum;
}
关于这种优化，个人感觉意义不大，日常开发还是从可读性的角度出发吧。
总结
以上介绍的七种优化手段，有时候会嵌套使用，比如说字段存储优化过程中还会使用到复写传播的手段，当然也有某些优化比较复杂，可读性不高，比如说循环展开和循环判断外提。综上，我们需要学习的优化手段最好先保证良好的可读性，在此基础上省略即时编译器的工作。
参考文献
《深入理解Java虚拟机》
转载自:https://juejin.cn/post/7080131449973637127