常量折叠

常量折叠是Java在编译期做的一个优化，简单的来说，在编译期就把一些表达式计算好，不需要在运行时进行计算。
比如: int a = 1 + 2，经过常量折叠后就变成了int a = 3。
我们举个例子:

public class Main {
    public static void main(String[] args) {
        String s1 = "a" + "bc";
        String s2 = "ab" + "c";
        System.out.println(s1 == s2);
    }
}

执行结果为true。
我们使用javac编译之后，在通过反编译工具（这个有个网站可以用）看下编译器优化后的代码:

public class Main {
   public static void main(String[] var0) {
      String var1 = "abc";
      String var2 = "abc";
      System.out.println(var1 == var2);
   }
}

var1和var2的值都是常量池中的”abc”，是同一个引用，所以会相等。
修改下我们的例子:

public class Main {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String s1= a + b;
        String s2= a + b;
        System.out.println(s1 == s2);
    }
}

执行结果为: false。
我们反编译生成的class文件:

public class Main {

   public static void main(String[] var0) {
      String var1 = "a";
      String var2 = "b";
      String var3 = var1 + var2;
      String var4 = var1 + var2;
      System.out.println(var3 == var4);
   }
}

我们知道，对于字符串进行 a + b的代码，运行中是这样处理的:
String s2 = (new StringBuffer()).append(a).append(b).toString();
所以最终得到的s1和s2是不相等(==)的。
第一个例子就是“常量折叠”，并不是所有的常量都会进行折叠，必须是编译期常量之间进行运算才会进行常量折叠，编译器常量就是编译时就能确定其值的常量，这个定义很严格，需要满足以下条件:
1. 字面量是编译期常量（数字字面量，字符串字面量等）。
2. 编译期常量进行简单运算的结果也是编译期常量，如1+2，”a”+”b”。
3. 被编译器常量赋值的 final 的基本类型和字符串变量也是编译期常量。

最后我们举一个final标识的常量折叠的例子:

public class Main {
    static final String a = "a";
    static final String b = "b";
    public static void main(String[] args) {
        String s1= a + b;
        String s2= a + b;
        System.out.println(s1 == s2);
    }
}

输出结果为: true
反编译的结果如下:

public class Main {

   static final String a = "a";
   static final String b = "b";

   public static void main(String[] var0) {
      String var1 = "ab";
      String var2 = "ab";
      System.out.println(var1 == var2);
   }
}

常量折叠,故名思议，在编译优化时，多个变量进行计算时，而且能够直接计算出结果，那么变量将由常量直接替换。如：

 void main()
{
      int a = 3+1-1*5;
      printf("%d",a);
}

优化为：

void main()
{
     printf("%d",-1);
}

常量传播

void main()
 {
     int a = 1;
     printf("%d",a);
 }

编译器在进行编译的时候，将a直接由1代替。

优化后如下：

 void main()
{
     printf("%d",1);
}

Global Value Numbering

Global Value Numbering（GVN） 是一种因为Sea-of-Nodes变得非常容易的优化技术 。

GVN是指为每一个计算得到的值分配一个独一无二的编号，然后遍历指令寻找优化的机会，它可以发现并消除等价计算的优化技术。如果一段程序中出现了多次操作数相同的乘法，那么即时编译器可以将这些乘法合并为一个，从而降低输出机器码的大小。如果这些乘法出现在同一执行路径上，那么GVN还将省下冗余的乘法操作。在Sea-of-Nodes中，由于只存在值的概念，因此GVN算法将非常简单：即时编译器只需判断该浮动节点是否与已存在的浮动节点的编号相同，所输入的IR节点是否一致，便可以将这两个浮动节点归并成一个。比如下面这段代码：

GVN

a = 1;
b = 2;
c = a + b;
d = a + b;
e = d;

GVN会利用Hash算法编号，计算a = 1时，得到编号1，计算b = 2时得到编号2，计算c = a + b时得到编号3，这些编号都会放入Hash表中保存，在计算d = a + b时，会发现a + b已经存在Hash表中，就不会再进行计算，直接从Hash表中取出计算过的值。最后的e = d也可以由Hash表中查到而进行复用。

可以将GVN理解为在IR图上的公共子表达式消除（Common Subexpression Elimination，CSE）。两者区别在于，GVN直接比较值的相同与否，而CSE是借助词法分析器来判断两个表达式相同与否。

对于更详细的编译优化请看
JVM C1 编译优化：合并相同的表达式-Global Value Numbering 之实现
javac 编译与 JIT 编译