优化期间 Java 会内联方法吗？

Question

我想知道 JVM/javac 是否足够聪明，可以变成

// This line...
string a = foo();

string foo()
{
  return bar();
}

string bar()
{
  return some-complicated-string computation;
}

或

string a = bar();

在发布情况下删除对 foo() 不必要的调用（因为无法访问代码）：

string a = foo(bar());

// bar is the same
...

string foo(string b)
{
  if (debug) do-something-with(b);
}

对于第一个示例，我的感觉是肯定的，而对于第二个示例，我的感觉是“不太确定”，但可以有人给我一些指示/链接来确认这一点吗？

Answer 1

javac 将呈现字节码，该字节码是生成字节码的原始 Java 程序的忠实表示（除非在某些可以优化的情况下：不断折叠和死机）代码消除）。然而，当 JVM 使用 JIT 编译器时，可能会执行优化。

对于第一个场景，JVM 似乎支持内联（请参阅方法 此处 并查看 此处有关 JVM 上的内联示例）。

我找不到任何由 javac 本身执行方法内联的示例。我尝试编译一些示例程序（类似于您在问题中描述的程序），但它们似乎都没有直接内联该方法，即使它是最终的。看起来这些类型的优化是由 JVM 的 JIT 编译器完成的，而不是由 javac 完成的。 方法下提到的“编译器”这里似乎是HotSpot JVM的JIT编译器，而不是javac。

据我所知，javac 支持死代码消除（请参阅第二种情况的示例）和常量折叠。在常量折叠中，编译器将预先计算常量表达式并使用计算出的值，而不是在运行时执行计算。例如：

public class ConstantFolding {

   private static final int a = 100;
   private static final int b = 200;

   public final void baz() {
      int c = a + b;
   }
}

编译为以下字节码：

Compiled from "ConstantFolding.java"
public class ConstantFolding extends java.lang.Object{
private static final int a;

private static final int b;

public ConstantFolding();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public final void baz();
  Code:
   0:   sipush  300
   3:   istore_1
   4:   return

}

请注意，该字节码具有 sipush 300 而不是 aload 的 getfield 和一个 iadd。 300 是计算值。 private Final 变量也是如此。如果 a 和 b 不是静态的，则生成的字节码将为：

Compiled from "ConstantFolding.java"
public class ConstantFolding extends java.lang.Object{
private final int a;

private final int b;

public ConstantFolding();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   bipush  100
   7:   putfield    #2; //Field a:I
   10:  aload_0
   11:  sipush  200
   14:  putfield    #3; //Field b:I
   17:  return

public final void baz();
  Code:
   0:   sipush  300
   3:   istore_1
   4:   return

}

这里也使用 sipush 300。

对于第二种情况（死代码消除），我使用了以下测试程序：

public class InlineTest {

   private static final boolean debug = false;

   private void baz() {
      if(debug) {
         String a = foo();
      }
   }

   private String foo() {
      return bar();
   }

   private String bar() {
      return "abc";
   }
}

它给出了以下字节码：

Compiled from "InlineTest.java"
public class InlineTest extends java.lang.Object{
private static final boolean debug;

public InlineTest();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

private void baz();
  Code:
   0:   return

private java.lang.String foo();
  Code:
   0:   aload_0
   1:   invokespecial   #2; //Method bar:()Ljava/lang/String;
   4:   areturn

private java.lang.String bar();
  Code:
   0:   ldc #3; //String abc
   2:   areturn

}

如您所见，foo在baz 因为 if 块内的代码实际上是“死的”。

Sun 的（现在是 Oracle 的）HotSpot JVM 结合了字节码解释和 JIT 编译。当字节码提供给 JVM 时，代码最初会被解释，但 JVM 将监视字节码并挑选出经常执行的部分。它将这些部分转换为本机代码，以便它们运行得更快。对于不经常使用的字节码，不进行此编译。这也很好，因为编译有一些开销。所以这实际上是一个权衡的问题。如果您决定将所有字节码编译为本机代码，那么代码可能会有很长的启动延迟。

除了监视字节码之外，JVM 还可以在解释和加载字节码时对字节码进行静态分析以执行进一步的优化。

如果您想了解 JVM 执行的具体类型的优化，此页面非常有帮助。它描述了 HotSpot JVM 中使用的性能技术。

Answer 2

JVM 很可能会内联。一般来说，最好针对人类可读性进行优化。让 JVM 进行运行时优化。

JVM 专家 Brian Goetz 说 final 对内联方法没有影响。

Answer 3

在同一个类文件中，javac 将能够内联 static 和 final （其他类文件可能会更改内联函数），

但是 JIT 将能够优化更多（包括内联多余的删除边界和空检查等），因为它了解更多关于代码的信息

Answer 4

“高度优化”的 JIT 编译器将内联这两种情况（并且，@Mysticial，它甚至可能通过采用各种形式的欺骗来内联一些多态情况）。

您可以通过将方法设为最终方法以及其他一些技巧来增加内联的机会。

javac 做了一些原始内联，主要是最终/私有方法，主要是为了帮助一些条件编译范例。

Answer 5

如果你在 bar() 中抛出异常并打印堆栈跟踪，你将看到调用的整个路径......我认为 java 尊重所有这些。

第二种情况是一样的，debug只是你系统的一个变量，而不是像C++中的定义，所以之前必须对其进行评估。

Answer 6

我可能是错的，但我的感觉是“在所有情况下都不会”。因为您的 string bar() 可能会被同一包中的其他类重载而覆盖。 final 方法是不错的选择，但它取决于 JIT。

另一个有趣的注释是这里< /a>.