当前位置: 首页 > article >正文

JVM常用概念之信任非静态final字段

问题

JVM可以信任非静态的final字段吗?

基础知识

编译器通常信任static final字段,因为已知该值不依赖于特定对象,并且已知它不会改变。那对于静态常量实例的final字段也使如此吗?

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;
}

Java 言规范允许不看到这样的更新,因为字段是final 。不幸的是,真正的框架设法依赖于更强大的行为:字段更新将被看到。正在进行的实验积极优化这些情况,并在实际写入发生时取消优化。当前状态是一些内部类是隐式信任的,下面是OpenJDK的源码:

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;
}

并且,只有在提供实验性的 -XX:+TrustFinalNonStaticFields运行参数时,常规的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;         }

}

运行结果

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

汇编代码如下:

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 ),但我们不信任该字段!使用 -XX:+TrustFinalNonStaticFields 运行相同操作会产生以下结果:

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

总结

信任实例最终字段需要了解我们正在操作的对象。因此,至少对于已知的系统类而言。通过这些最终字段进行常量折叠是MethodHandle -s、 VarHandle -s`、 Atomic*FieldUpdaters和核心库中其他高性能实现的性能基础。应用程序可能会尝试使用实验性的 VM 选项,但行为不当的应用程序可能造成的破坏可能会得不偿失。


http://www.kler.cn/a/588750.html

相关文章:

  • Podman 1panel中容器管理docker替换为Podman
  • OpenSSL 的主要功能及其示例命令
  • 网络空间安全(31)安全巡检
  • 【eNSP实战】配置Easy IP
  • DataWhale 大语言模型 - 长上下文模型和新型架构
  • 排序算法——堆排序(四)
  • C++|构造函数和析构函数
  • java自带日志系统介绍(JUL)以及和Log4j 2、Logback、SLF4J不同日志工具的对比
  • leetcode日记(99)不同的子序列
  • PyTorch使用-张量的创建
  • CSS 知识点总结1
  • 【软考-架构】7、系统配置与性能评价
  • CAD球体密堆积3D插件V2.0
  • SpringBoot手动注册定时任务
  • ActiveMQ监听器在MQ重启后不再监听问题
  • Pytorch:Dataset的加载
  • 百度贴吧IP和ID是什么意思?怎么查看
  • NPU、边缘计算与算力都是什么啊?
  • [leetcode] 面试经典 150 题——篇3:滑动窗口
  • 一分钟了解深度学习