什么是方法内联？

Question

我一直试图理解这真正意味着什么：

内联函数

在 C++ 中，定义的成员函数 类声明。 (2) 函数 调用编译器替换为 该函数的实际代码。这 关键字 inline 可用于提示 编译器执行内联 成员身体的扩张或 非成员函数。

内联

用副本替换函数调用 期间函数的代码 编译。

例如，它是这样写的：

当一个方法是final时，它可能是 内联。

这里： http://www.roseindia.net/javatutorials/final_methods.shtml

你可以吗给我一个例子或其他东西，或者基本上帮助我理解“它可能被内联”的含义。

谢谢。

Answer 1

内联是 Java 即时编译器执行的优化。

如果你有一个方法：

public int addPlusOne(int a, int b) {
  return a + b + 1;
}

你像这样调用它：

public void testAddPlusOne() {
  int v1 = addPlusOne(2, 5);
  int v2 = addPlusOne(7, 13);

  // do something with v1, v2
}

编译器可能决定用函数体替换你的函数调用，所以结果实际上看起来像这样：

public void testAddPlusOne() {
  int v1 = 2 + 5 + 1;
  int v2 = 7 + 13 + 1

  // do something with v1, v2
}

编译器这样做是为了节省实际创建函数的开销调用，这将涉及将每个参数推入堆栈。

显然，这只能针对非虚拟函数来完成。考虑一下如果该方法在子类中被重写并且包含该方法的对象的类型直到运行时才知道会发生什么...编译器如何知道要复制哪些代码：基类的方法体或子类的方法体方法体？由于 Java 中所有方法默认都是虚拟的，因此您可以显式地将那些无法重写的方法标记为 final（或将它们放入 final 类中）。这将帮助编译器确定该方法永远不会被重写，并且内联是安全的。 （请注意，编译器有时也可以对非最终方法做出此确定。）

此外，请注意引用中的单词可能。最终方法不保证是内联的。有多种方法可以保证方法不能被内联，但没有办法强制编译器内联。无论如何，它几乎总是比你更了解内联何时有助于或损害生成代码的速度。

请参阅 wikipedia 以全面了解优点和问题。

Answer 2

假设您有一个如下所示的类：

public class Demo {
    public void method() {
        // call printMessage
        printMessage();
    }

    public void printMessage() {
        System.out.println("Hello World");
    }
}

对 printMessage 的调用可以通过以下方式“内联”：（

public class Demo {
    public void method() {
        // call printMessage
        System.out.println("Hello World"); // <-- inlined
    }

    public void printMessage() {
        System.out.println("Hello World");
    }
}

这实际上不是在 Java 级别上完成的（甚至在字节码级别上也没有）但在 JIT 编译期间，但上面的示例说明了内联的概念。）

现在考虑如果 printMessage 方法被另一个类重载会发生什么，如下所示

class SubDemo extends Demo {
    public void printMessage() {
        System.out.println("Something else");
    }
}

：如果编译器内联对 Demo.printMessage 的调用，它将被困在 System.out.println("Hello World"); 中，这是错误 如果该对象实际上是 SubDemo 的实例。

但是，如果该方法被声明为final，则在任何情况下都不会出现这种情况。如果该方法是“最终”的，则意味着它永远不能被新定义覆盖，因此，内联它是安全的！

Answer 3

调用函数不是免费的。机器必须维护一个堆栈帧，以便在被调用函数完成时可以返回到代码的调用部分。维护堆栈（包括在该堆栈上传递函数参数）需要时间。

当函数内联时，编译器会用函数代码替换对该函数的调用，这样就可以避免运行时函数调用的性能损失。这是编程中的经典权衡之一：运行时代码变得更大一些（占用更多内存），但运行速度更快一些。