是否可以禁用 javac 的静态最终变量内联？

Question

Java 静态编译器 (javac) 内联了一些静态最终变量，并将这些值直接带入常量池。考虑以下示例。 A类定义了一些常量（public static final variables）：

public class A {
    public static final int INT_VALUE = 1000;
    public static final String STRING_VALUE = "foo";
}

B 类使用这些常量：

public class B {
    public static void main(String[] args) {
        int i = A.INT_VALUE;
        System.out.println(i);
        String s = A.STRING_VALUE;
        System.out.println(s);
    }
}

当你编译 B 类时，javac 从 A 类中获取这些常量的值并将这些值内联到 B.class 中。结果，在编译时必须对类 A 的依赖项 B 从字节码中删除。这是一种相当奇特的行为，因为您在编译时输入了这些常量的值。你会认为这是 JIT 编译器在运行时可以做的最简单的事情之一。

是否有任何方法或任何隐藏的编译器选项可以让您禁用 javac 的这种内联行为？作为背景，我们正在研究出于依赖性目的进行字节码分析，这是字节码分析无法检测编译时依赖性的少数情况之一。谢谢！

编辑：这是一个令人烦恼的问题，因为通常我们不会控制所有源（例如定义常量的第三方库）。我们有兴趣从使用常量的角度检测这些依赖关系。由于引用已从使用常量的代码中删除，因此没有简单的方法来检测它们，除非进行源代码分析。

Answer 1

Java Puzzlers (Joshua Bloch) 的第 93 项说，您可以通过防止最终值被视为常量来解决此问题。例如：

public class A {
  public static final int INT_VALUE = Integer.valueOf(1000).intValue();
  public static final String STRING_VALUE = "foo".toString();
}

当然，如果您无权访问定义常量的代码，这一切都无关紧要。

Answer 2

我不相信。最简单的解决方法是将这些公开为属性而不是字段：

public class A {
    private static final int INT_VALUE = 1000;
    private static final String STRING_VALUE = "foo";

    public static int getIntValue() {
        return INT_VALUE;
    }
    public static String getStringValue() {
        return STRING_VALUE;
    }
}

不要忘记，在某些情况下，内联对于值的使用是必不可少的——例如，如果您要在 switch 块中使用 INT_VALUE 作为 case，则 具有被指定为一个常数值。

Answer 3

要停止内联，您需要使值成为非编译时常量（JLS 术语）。您可以在不使用函数的情况下执行此操作，并通过在初始化表达式中使用 null 创建最少的字节码。

public static final int INT_VALUE = null!=null?0: 1000;

虽然它的代码生成非常直接，javac 应该将其优化为推送一个立即整数，然后存储到静态初始化器中的静态字段。

Answer 4

JLS 13.4.9 处理这个问题。他们的建议是，如果值可能以任何方式发生变化，则基本上避免使用编译时常量。

（需要内联的一个原因 常量是switch语句 在每种情况下都需要常量，并且没有 两个这样的常数值可能是 相同的。编译器检查 在开关中重复常量值 编译时的声明；班上 文件格式不做符号 案例值的链接。）

避免问题的最佳方法 “不定常数”在 广泛分布的代码是声明 作为编译时常量仅值 这真的不太可能 改变。除了真实 数学常数，我们推荐 该源代码非常节省使用 声明的类变量 静态和最终。如果只读 最终的性质是必需的，一个更好的 选择是声明一个私有静态 变量和合适的访问器 方法来获取它的值。因此我们 推荐：

private static int N;
public static int getN() { return N; }

而不是：

public static final int N = ...;

没有问题：

public static int N = ...;

如果 N 不需要是只读的。

Answer 5

我认为这是一个严重错误。 Java 不是 C/C++。有一个原则（或没有）“一次编译，到处运行”。

在这种情况下，当 A 类更改时。任何引用 A.CONST_VALUE 的类都必须重新编译，它们几乎不知道 A 类是否被更改。

Answer 6

像这样重写A类：

public class A {
    public static final int INT_VALUE;
    public static final String STRING_VALUE;

    static {
        INT_VALUE = 1000;
        STRING_VALUE = "foo";
    }
}

Answer 7

jmake 是一个开源项目，声称可以完成跟踪 Java 文件之间的依赖关系和增量编译所需的最小文件集的全部工作。它声称可以正确处理对静态最终常量的更改，尽管有时需要重新编译整个项目。它甚至以比类文件更精细的粒度来处理更改；如果（例如）方法 C.m() 的签名发生变化，那么它只会重新编译实际依赖于 m() 的类，而不是所有使用 C 的类。

免责声明：我没有使用 jmake 的经验。

Answer 8

我最近遇到了一个类似的issue，正如上面所说，这种内联可以使用非编译时表达式来解决，比如：

public final class A {

    public static final int INT_VALUE = constOf(1000);
    public static final String STRING_VALUE = constOf("foo");

}

constOf 方法族仅仅是：

// @formatter:off
public static boolean constOf(final boolean value) { return value; }
public static byte constOf(final byte value) { return value; }
public static short constOf(final short value) { return value; }
public static int constOf(final int value) { return value; }
public static long constOf(final long value) { return value; }
public static float constOf(final float value) { return value; }
public static double constOf(final double value) { return value; }
public static char constOf(final char value) { return value; }
public static <T> T constOf(final T value) { return value; }
// @formatter:on

这比 Integer.valueOf(1000).intValue() 或 null!=null?0: 1000 等其他建议短一些

Answer 9

我觉得 java 非常依赖动态编译，它不像 C++ 那样做任何花哨的编译逻辑。

您可以尝试使用 JIT 编译器的一些选项来进行运行时优化，这些选项可能有一些选项来禁用/启用它。

在默认 javac 中，您可能无法获得该选项。你必须使用 1. 某种类型的依赖图，如扩展或实现 2. 使用基于方法的链接。

-s