原文地址：JVM Anatomy Park #17: Trust Nonstatic Final Fields

問題

JVM 是否可以信任非靜態(tài) final 字段？

理論

正如我們在《#15: 即時(shí)常量》中提到的，編譯器信任 static final 字段，因?yàn)檫@個(gè)值不依賴特定對象，而且是不能改變的。但是如果我們準(zhǔn)確的知道對象身份，例如引用自身是 static final，那么我們可以信任它的 final 實(shí)例字段么？例如：

class M {
  final int x;
  M(int x) { this.x = x; }
}

static final M KNOWN_M = new M(1337);

void work() {
  // We know exactly the slot that holds the variable, can we just
  // inline the value 1337 here?
  return KNOWN_M.x;
}

棘手的問題是，如果字段被修改，會(huì)發(fā)生什么？《Java 語言規(guī)范》允許看不到這樣的更新，因?yàn)樽侄问?final 的。很不幸，真正的框架設(shè)法依靠更強(qiáng)的行為：字段更新將會(huì)被看到。下面將要進(jìn)行的實(shí)驗(yàn)激進(jìn)地優(yōu)化了這些場景，當(dāng)寫操作發(fā)生的時(shí)候就嘗試逆優(yōu)化。當(dāng)前的狀態(tài)是只有某些內(nèi)部類是隱式信任的：

static bool trust_final_non_static_fields(ciInstanceKlass* holder) {
  if (holder == NULL)
    return false;
  if (holder->name() == ciSymbol::java_lang_System())
    // Never trust strangely unstable finals:  System.out, etc.
    return false;
  // Even if general trusting is disabled, trust system-built closures in these packages.
  if (holder->is_in_package("java/lang/invoke") || holder->is_in_package("sun/invoke"))
    return true;
  // Trust VM anonymous classes. They are private API (sun.misc.Unsafe) and can't be serialized,
  // so there is no hacking of finals going on with them.
  if (holder->is_anonymous())
    return true;
  // Trust final fields in all boxed classes
  if (holder->is_box_klass())
    return true;
  // Trust final fields in String
  if (holder->name() == ciSymbol::java_lang_String())
    return true;
  // Trust Atomic*FieldUpdaters: they are very important for performance, and make up one
  // more reason not to use Unsafe, if their final fields are trusted. See more in JDK-8140483.
  if (holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicIntegerFieldUpdater_Impl() ||
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicLongFieldUpdater_CASUpdater() ||
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicLongFieldUpdater_LockedUpdater() ||
      holder->name() == ciSymbol::java_util_concurrent_atomic_AtomicReferenceFieldUpdater_Impl()) {
    return true;
  }
  return TrustFinalNonStaticFields;
}

當(dāng)提供實(shí)驗(yàn)性的 -XX:+TrustFinalNonStaticFields 參數(shù)的時(shí)候，常規(guī)的 final 字段才被信任。

實(shí)踐

我們可以在實(shí)踐中觀察么？修改 《#15: 即時(shí)常量》中的 JMH 測試用例，使用對象中的 final 字段，而不是對象本身：

@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(3)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
public class TrustFinalFields {

    static final T t_static_final;
    static       T t_static;
           final T t_inst_final;
                 T t_inst;

    static {
        t_static_final = new T(1000);
        t_static = new T(1000);
    }

    {
        t_inst_final = new T(1000);
        t_inst = new T(1000);
    }

    static class T {
        final int x;

        public T(int x) {
            this.x = x;
        }
    }

    @Benchmark public int _static_final() { return 1000 / t_static_final.x; }
    @Benchmark public int _static()       { return 1000 / t_static.x;       }
    @Benchmark public int _inst_final()   { return 1000 / t_inst_final.x;   }
    @Benchmark public int _inst()         { return 1000 / t_inst.x;         }

}

在我的機(jī)器上，這個(gè)測試用例輸出：

Benchmark                       Mode  Cnt  Score   Error  Units
TrustFinalFields._inst          avgt   15  4.316 ± 0.003  ns/op
TrustFinalFields._inst_final    avgt   15  4.317 ± 0.002  ns/op
TrustFinalFields._static        avgt   15  4.282 ± 0.011  ns/op
TrustFinalFields._static_final  avgt   15  4.202 ± 0.002  ns/op

看起來 static final 并沒有太大幫助。確實(shí)如此，你可以看一下生成的指令：

0.02%   ↗  movabs $0x782b67520,%r10   ; {oop(a 'org/openjdk/TrustFinalFields$T';)}
        │  mov    0x10(%r10),%r10d    ; get field $x
        │  ...
0.19%   │  cltd
0.02%   │  idiv   %r10d               ; idiv
        │  ...
0.16%   │  test   %r11d,%r11d         ; check and run @Benchmark again
        ╰  je     BACK

對象被信任位于堆中的給定位置（$0x782b67520），但是我們不信任這個(gè)字段！配置參數(shù) -XX:+TrustFinalNonStaticFields，再運(yùn)行：

Benchmark                       Mode  Cnt  Score    Error  Units
TrustFinalFields._inst          avgt   15  4.318 ±  0.001  ns/op
TrustFinalFields._inst_final    avgt   15  4.317 ±  0.003  ns/op
TrustFinalFields._static        avgt   15  4.290 ±  0.002  ns/op
TrustFinalFields._static_final  avgt   15  1.901 ±  0.001  ns/op  # <--- !!!

這次 final 字段被折疊了，就像我們在 perfasm 輸出中看到的：

3.04%   ↗  mov    %r10,(%rsp)
        │  mov    0x38(%rsp),%rsi
8.26%   │  mov    $0x1,%edx           ; <--- constant folded to 1
        │  ...
0.04%   │  test   %r11d,%r11d         ; check and run @Benchmark again
        ╰  je     BACK

觀察

如果要信任實(shí)例 final 字段，那么必須知道當(dāng)前操作的對象。但即使是這樣，當(dāng)我們確定它不會(huì)破壞應(yīng)用程序時(shí)，我們可以務(wù)實(shí)地這樣做 —— 至少對已知的系統(tǒng)類可以。對于來自核心庫的 MethodHandle、VarHandle、Atomic*FieldUpdaters 等高性能實(shí)現(xiàn)，折疊 final 字段為常量是實(shí)現(xiàn)高性能的基石。應(yīng)用程序可以嘗試使用實(shí)驗(yàn)性的 VM 參數(shù)，但是來自不正常應(yīng)用程序的潛在危害可能會(huì)嚴(yán)重抑制性能收益。