当前位置:首页 > 数码 > 解释和编译指南-JVM (解释和编译指的是)

解释和编译指南-JVM (解释和编译指的是)

admin3周前 (04-28)数码16

是一种跨平台的编程言语。程序源代码会被编译为字节码bytecode,而后字节码在运转时被转换为机器码hinecode。解释器interpreter在物理机器上模拟出的形象计算机上口头字节码指令。即时just-in-time(JIT)编译出当初运转期,而预先ahead-of-time(AOT)编译出当初构建期。

本文将说明解释器、JIT和AOT区分何时起作用,以及如何在JIT和AOT之间掂量。

源代码、字节码、机器码

运行程序通常是由C、C++或Java等编程言语编写。用这些初级编程言语编写的指令汇合称为源代码。源代码是人类可读的。要在指标机器上口头它,须要将源代码转换为机器可读的机器码。这个转换上班通常是由编译器compiler

但是,在Java中,源代码首先被转换为一种两边方式,称为字节码。字节码是平台有关的,所以Java被称为平台有关编程言语。Java编译器将源代码转换为字节码。而后解释器解释口头字节码。

上方是一个繁难的Java程序, Hello.java

//Hello.javapublicclassHello{publicstaticvoidmn(String[]args){System.out.println("InsideHelloWorld!");}}

经常使用编译它,生成蕴含字节码的 Hello.class 文件。

$javacHello.java$lsHello.classHello.java

如今,经常使用来反汇编 Hello.class 文件的内容。经常使用时假设不指定任何选项,它将打印基本消息,包括编译这个文件的源文件、包称号、公共和受包全字段以及类的方法。

$javapHello.classCompiledfrom"Hello.java"publicclassHello{publicHello();publicstaticvoidmain(java.lang.String[]);}

要检查文件中的字节码内容,经常使用选项:

$javap-cHello.classCompiledfrom"Hello.java"publicclassHello{publicHello();Code:0:aload_01:invokespecial#1//Methodjava/lang/Object."<init>":()V4:returnpublicstaticvoidmain(java.lang.String[]);Code:0:getstatic#2//Fieldjava/lang/System.out:Ljava/io/PrintStream;3:ldc#3//StringInsideHelloWorld!5:invokevirtual#4//Methodjava/io/PrintStream.println:(Ljava/lang/String;)V8:return}

要失掉更详细的消息,经常使用选项:

$javap-vHello.class

解释器,JIT和AOT

解释器担任在物理机器上模拟出的形象计算机上口头字节码指令。当经常使用编译源代码,而后经常使用口头时,解释器在程序运转时运转并成功它的指标。

$javacHello.java$javaHelloInsideHelloWorld!

JIT编译器也在运转期施展作用。当解释器解释Java程序时,另一个称为运转时剖析器profiler的组件将静默地监督程序的口头,统计各局部代码被解释的次数。基于这些统计消息可以检测出程序的热点hotspot,即那些经常被解释的代码。一旦代码被解释次数超越设定的阈值,它们满足被JIT编译器间接转换为机器码的条件。所以JIT编译器也被称为剖析优化的编译器。从字节码到机器码的转换是在程序运转环节中启动的,因此称为即时编译。JIT缩小了解释器将同一组指令模拟为机器码的累赘。

AOT编译器在构建期编译代码。在构建时将须要频繁解释和JIT编译的代码间接编译为机器码可以缩短Java虚构机JavaVirtualMachine(JVM)的预热warm-up期间。(LCTT译注:Java程序启动后首先字节码被解释口头,此时口头效率较低。等到程序运转了足够的期间后,代码热点被检测进去,JIT开局施展作用,程序运转效率优化。JIT施展作用之前的环节就是预热。)AOT是在Java9中引入的一个试验性个性。经常使用Graal编译器(它自身也是用Java编写的)来成功AOT编译。

Hello.java 为例:

//Hello.javapublicclassHello{publicstaticvoidmain(String[]args){System.out.println("InsideHelloWorld!");}}$javacHello.java$jaotc--outputlibHello.soHello.class$java-XX:+UnlockExperimentalVMOptions-XX:AOTLibrary=./libHello.soHelloInsideHelloWorld!

解释和编译出现的机遇

上方经过例子来展现Java在什么时刻经常使用解释器,以及JIT和AOT何时介入出去。这里有一个繁难的程序:

//Demo.javapublicclassDemo{publicintsquare(inti)throwsException{return(i*i);}publicstaticvoidmain(String[]args)throwsException{for(inti=1;i<=10;i++){System.out.println("call"+Integer.valueOf(i));longa=System.nanoTime();Intr=newDemo().square(i);System.out.println("Square(i)="+r);longb=System.nanoTime();System.out.println("elapsed="+(b-a));System.out.println("--------------------------------");}}}

在这个程序的方法中创立了一个对象的实例,并调用该实例的方法,而后显示循环迭代变量的平方值。编译并运转它:

$javacDemo.java$javaDemo1iterationSquare(i)=1Timetaken=8432439--------------------------------2iterationSquare(i)=4Timetaken=54631--------------------------------...--------------------------------10iterationSquare(i)=100Timetaken=66498--------------------------------

上方的结果是由谁发生的呢?是解释器,JIT还是AOT?在目前的状况下,它齐全是经过解释发生的。我是怎样得出这个论断的呢?只要代码被解释的次数必需超越某个阈值时,这些热点代码片段才会被参与JIT编译队列。只要这时,JIT编译才会施展作用。经常使用以下命令检查JDK11中的该阈值:

$java-XX:+PrintFlagsFinal-version|grepCompileThresholdintxCompileThreshold=10000{pdproduct}{default}[...]openjdkversion"11.0.13"2021-10-19OpenJDKRuntimeEnvironment18.9(build11.0.13+8)OpenJDK64-BitServerVM18.9(build11.0.13+8,mixedmode,sharing)

上方的输入标明,一段代码被解释10,000次才合乎JIT编译的条件。这个阈值能否可以手动调整呢?能否有JVM标记可以批示出方法能否被JIT编译了呢?答案是必需的,而且有多种方式可以到达这个目的。

经常使用 -XX:+PrintCompilation 选项可以检查一个方法能否被JIT编译。除此之外,经常使用标记可以提高输入的可读性。假设解释和JIT同时出现,可以协助区分两者的输入。经常使用这些标记如下:

$java-Xbatch-XX:+PrintCompilationDemo341b3java.util.concurrent.ConcurrentHashMap::tabAt(22bytes)352n0jdk.internal.misc.Unsafe::getObjectVolatile(native)353b3java.lang.Object::<init>(1bytes)[...]210269n0java.lang.reflect.Array::newArray(native)(static)211270b3java.lang.String::substring(58bytes)[...]--------------------------------10iterationSquare(i)=100Timetaken=50150--------------------------------

留意,上方命令的实践输入太长了,这里我只是截取了一局部。输入很长的要素是除了程序的代码外,JDK外部类的函数也被编译了。由于我的重点是代码,我宿愿扫除外部包的函数来简化输入。经过选项 -XX:CompileCommandFile 可以禁用外部类的JIT:

$java-Xbatch-XX:+PrintCompilation-XX:CompileCommandFile=hotspot_compilerDemo

在选项 -XX:CompileCommandFile 指定的文件 hotspot_compiler 中蕴含了要扫除的包:

$cathotspot_compilerquietexcludejava/**excludejdk/**excludesun/**

第一行的通知JVM不要输入任何关于被扫除类的内容。用 -XX:CompileThreshold 将JIT阈值设置为5。这象征着在解释5次之后,就会启动JIT编译:

$java-Xbatch-XX:+PrintCompilation-XX:CompileCommandFile=hotspot_compiler-XX:CompileThreshold=5Demo471n0java.lang.invoke.MethodHandle::linkToStatic(LLLLLL)L(native)(static)472n0java.lang.invoke.MethodHandle::invokeBasic(LLLLL)L(native)473n0java.lang.invoke.MethodHandle::linkToSpecial(LLLLLLL)L(native)(static)484n0java.lang.invoke.MethodHandle::linkToStatic(L)I(native)(static)485n0java.lang.invoke.MethodHandle::invokeBasic()I(native)486n0java.lang.invoke.MethodHandle::linkToSpecial(LL)I(native)(static)[...]1iteration6940n0java.lang.invoke.MethodHandle::linkToStatic(ILIIL)I(native)(static)[...]Square(i)=17848n0java.lang.invoke.MethodHandle::linkToStatic(ILIJL)I(native)(static)7949n0java.lang.invoke.MethodHandle::invokeBasic(ILIJ)I(native)[...]8654n0java.lang.invoke.MethodHandle::invokeBasic(J)L(native)8755n0java.lang.invoke.MethodHandle::linkToSpecial(LJL)L(native)(static)Timetaken=8962738--------------------------------2iterationSquare(i)=4Timetaken=26759--------------------------------10iterationSquare(i)=100Timetaken=26492--------------------------------

如同输入结果跟只用解释时并没有什么区别。依据Oracle的文档,这是由于只要禁用 TieredCompilation -XX:CompileThreshold 才会失效:

$java-Xbatch-XX:+PrintCompilation-XX:CompileCommandFile=hotspot_compiler-XX:-TieredCompilation-XX:CompileThreshold=5Demo1241njava.lang.invoke.MethodHandle::linkToStatic(LLLLLL)L(native)(static)1272njava.lang.invoke.MethodHandle::invokeBasic(LLLLL)L(native)[...]1iteration18740njava.lang.invoke.MethodHandle::linkToStatic(ILIIL)I(native)(static)[...](native)(static)21254njava.lang.invoke.MethodHandle::invokeBasic(J)L(native)21255njava.lang.invoke.MethodHandle::linkToSpecial(LJL)L(native)(static)Timetaken=12337415[...]--------------------------------4iterationSquare(i)=16Timetaken=37183--------------------------------5iteration21456bDemo::<init>(5bytes)21557bDemo::square(16bytes)Square(i)=25Timetaken=983002--------------------------------6iterationSquare(i)=36Timetaken=81589[...]10iterationSquare(i)=100Timetaken=52393

可以看到在第五次迭代之后,代码片段被JIT编译了:

--------------------------------5iteration21456bDemo::<init>(5bytes)21557bDemo::square(16bytes)Square(i)=25Timetaken=983002--------------------------------

可以看到,与方法一同,结构方法也被JIT编译了。在循环中调用之前要先结构实例,所以结构方法的解释次数雷同到达JIT编译阈值。这个例子说明了在解释出现之后何时JIT会介入。

要检查编译后的代码,须要经常使用 -XX:+PrintAssembly 标记,该标记仅在库门路中有反汇编器时才起作用。关于OpenJDK,经常使用作为反汇编器。下载适合版本的反汇编程序库,在本例中是 hsdis-amd64.so ,并将其放在 Java_HOME/lib/server 目录下。经常使用时还须要在 -XX:+PrintAssembly 之前参与 -XX:+UnlockDiagnosticVMOptions 选项。否则,JVM会给你一个正告。

完整命令如下:

$java-Xbatch-XX:+PrintCompilation-XX:CompileCommandFile=hotspot_compiler-XX:-TieredCompilation-XX:CompileThreshold=5-XX:+UnlockDiagnosticVMOptions-XX:+PrintAssemblyDemo[...]5iteration17856bDemo::<init>(5bytes)Compiledmethod(c2)17856Demo::<init>(5bytes)totalinheap[0x00007fd4d08dad10,0x00007fd4d08dafe0]=720relocation[0x00007fd4d08dae88,0x00007fd4d08daea0]=24[...]handlertable[0x00007fd4d08dafc8,0x00007fd4d08dafe0]=24[...]dependencies[0x00007fd4d08db3c0,0x00007fd4d08db3c8]=8handlertable[0x00007fd4d08db3c8,0x00007fd4d08db3f8]=48----------------------------------------------------------------------Demo.square(I)I[0x00007fd4d08db1c0,0x00007fd4d08db2b8]248bytes[EntryPoint][Constants]#{method}{0x00007fd4b841f4b0}'square''(I)I'in'Demo'#this:rsi:rsi='Demo'#parm0:rdx=int#[sp+0x20](spofcaller)[...][StubCode]0x00007fd4d08db280:movabs$0x0,%rbx;{no_reloc}0x00007fd4d08db28a:jmpq0x00007fd4d08db28a;{runtime_call}0x00007fd4d08db28f:movabs$0x0,%rbx;{static_stub}0x00007fd4d08db299:jmpq0x00007fd4d08db299;{runtime_call}[ExceptionHandler]0x00007fd4d08db29e:jmpq0x00007fd4d08bb880;{runtime_callExceptionBlob}[DeoptHandlerCode]0x00007fd4d08db2a3:callq0x00007fd4d08db2a80x00007fd4d08db2a8:subq$0x5,(%rsp)0x00007fd4d08db2ad:jmpq0x00007fd4d08a01a0;{runtime_callDeoptimizationBlob}0x00007fd4d08db2b2:hlt0x00007fd4d08db2b3:hlt0x00007fd4d08db2b4:hlt0x00007fd4d08db2b5:hlt0x00007fd4d08db2b6:hlt0x00007fd4d08db2b7:hltImmutableOopMap{rbp=NarrowOop}pcoffsets:96ImmutableOopMap{}pcoffsets:112ImmutableOopMap{rbp=Oop}pcoffsets:148Square(i)=25Timetaken=2567698--------------------------------6iterationSquare(i)=36Timetaken=76752[...]--------------------------------10iterationSquare(i)=100Timetaken=52888

我只截取了输入中与相关的局部。

如今再来看看AOT编译。它是在JDK9中引入的个性。AOT是用于生成这样的库文件的静态编译器。用AOT可以将指定的类编译成库。这个库可以间接口头,而不用解释或JIT编译。假设JVM没有检测到AOT编译的代码,它会启动惯例的解释和JIT编译。

经常使用AOT编译的命令如下:

解释和编译指南$jaotc--output=libDemo.soDemo.class

用上方的命令来检查共享库的符号表:

$nmlibDemo.so

要经常使用生成的库,经常使用 -XX:+UnlockExperimentalVMOptions -XX:AOTLibrary

$java-XX:+UnlockExperimentalVMOptions-XX:AOTLibrary=./libDemo.soDemo1iterationSquare(i)=1Timetaken=7831139--------------------------------2iterationSquare(i)=4Timetaken=36619[...]10iterationSquare(i)=100Timetaken=42085

从输入上看,跟齐全用解释的状况没有区别。为了确认AOT施展了作用,经常使用 -XX:+PrintAOT

$java-XX:+UnlockExperimentalVMOptions-XX:AOTLibrary=./libDemo.so-XX:+PrintAOTDemo281loaded./libDemo.soaotlibrary801aot[1]Demo.main([Ljava/lang/String;)V802aot[1]Demo.square(I)I803aot[1]Demo.<init>()V1iterationSquare(i)=1Timetaken=7252921--------------------------------2iterationSquare(i)=4Timetaken=57443[...]10iterationSquare(i)=100Timetaken=53586

要确认没有出现JIT编译,用如下命令:

$java-XX:+UnlockExperimentalVMOptions-Xbatch-XX:+PrintCompilation-XX:CompileCommandFile=hotspot_compiler-XX:-TieredCompilation-XX:CompileThreshold=3-XX:AOTLibrary=./libDemo.so-XX:+PrintAOTDemo191loaded./libDemo.soaotlibrary771aot[1]Demo.square(I)I772aot[1]Demo.main([Ljava/lang/String;)V773aot[1]Demo.<init>()V772aot[1]Demo.main([Ljava/lang/String;)Vmadenotentrant[...]4iterationSquare(i)=16Timetaken=43366[...]10iterationSquare(i)=100Timetaken=59554

须要特意留意的是,修正被AOT编译了的源代码后,必定要重重生成库文件。否则,过期的的AOT编译库文件不会起作用。例如,修正方法,使其计算立方值:

//Demo.javapublicclassDemo{publicintsquare(inti)throwsException{return(i*i*i);}publicstaticvoidmain(String[]args)throwsException{for(inti=1;i<=10;i++){System.out.println(""+Integer.valueOf(i)+"iteration");longstart=System.nanoTime();intr=newDemo().square(i);System.out.println("Square(i)="+r);longend=System.nanoTime();System.out.println("Timetaken="+(end-start));System.out.println("--------------------------------");}}}

从新编译:

$javaDemo.java

但不重重生成 libDemo.so 。经常使用上方命令运转:

$java-XX:+UnlockExperimentalVMOptions-Xbatch-XX:+PrintCompilation-XX:CompileCommandFile=hotspot_compiler-XX:-TieredCompilation-XX:CompileThreshold=3-XX:AOTLibrary=./libDemo.so-XX:+PrintAOTDemo201loaded./libDemo.soaotlibrary741njava.lang.invoke.MethodHandle::linkToStatic(LLLLLL)L(native)(static)2iterationsqrt(i)=8Timetaken=43838--------------------------------3iteration13756bDemo::<init>(5bytes)13857bDemo::square(6bytes)sqrt(i)=27Timetaken=534649--------------------------------4iterationsqrt(i)=64Timetaken=51916[...]10iterationsqrt(i)=1000Timetaken=47132

可以看到,虽然旧版本的 libDemo.so 被加载了,但JVM检测出它曾经过期了。每次生成文件时,都会在类文件中参与一个指纹,并在AOT库中保留该指纹。修正源代码后类指纹与旧的AOT库中的指纹不婚配了,所以没有口头AOT编译生成的原生机器码。从输入可以看出,如今实践上是JIT在起作用(留意 -XX:CompileThreshold 被设置为了3)。

AOT和JIT之间的掂量

假设你的指标是缩小JVM的预热期间,请经常使用AOT,这可以缩小运转时累赘。疑问是AOT没有足够的数据来选择哪段代码须要预编译为原生代码。相比之下,JIT在运转时起作用,却对预热期间有必定的影响。但是,它将有足够的剖析数据来更高效地编译和反编译代码。


什么是Java的JVM?

Java的JVM(Java Virtual Machine)是Java程序运行的平台,它负责加载、执行Java字节码程序,并管理内存、废品回收等运行时操作。JVM是Java SE架构的重要组成部分,不同的JVM实现不同的Java规范,例如Sun公司的JVM实现了Java SE 5.0规范,IBM公司的JVM实现了Java SE 7及以上规范。

JVM的主要组成部分包括:

JVM的组成和运行原理是什么?

JVM是Java Virtual Machine(Java虚拟机)的缩写。

1、JVM的组成:

JVM 由类加载器子系统、运行时数据区、执行引擎以及本地方法接口组成。

2、JVM的运行原理:

JVM是java的核心和基础,在java编译器和os平台之间的虚拟处理器。它是一种基于下层的操作系统和硬件平台并利用软件方法来实现的抽象的计算机,可以在上面执行java的字节码程序。java编译器只需面向JVM,生成JVM能理解的代码或字节码文件。Java源文件经编译器,编译成字节码程序,通过JVM将每一条指令翻译成不同平台机器码,通过特定平台运行。

免责声明:本文转载或采集自网络,版权归原作者所有。本网站刊发此文旨在传递更多信息,并不代表本网赞同其观点和对其真实性负责。如涉及版权、内容等问题,请联系本网,我们将在第一时间删除。同时,本网站不对所刊发内容的准确性、真实性、完整性、及时性、原创性等进行保证,请读者仅作参考,并请自行核实相关内容。对于因使用或依赖本文内容所产生的任何直接或间接损失,本网站不承担任何责任。

标签: JVM

“解释和编译指南-JVM (解释和编译指的是)” 的相关文章

调优常用参数-JVM (调优常用参数是什么)

调优常用参数-JVM (调优常用参数是什么)

调优目的 JVM 调优的目的是为了提高应用程序的性能和稳定性。通过优化 JVM 的配置和参数设置,可以减少内存占用、提高废品回收效率、优化线程管理等,从而提升应用程序的响应速度、降低内存泄漏的风...

深入理解并发编程艺术之JVM内存模型 (深入理解并发扫描的含义)

深入理解并发编程艺术之JVM内存模型 (深入理解并发扫描的含义)

Java内存模型(Java Memory Model,简称JMM)是一种抽象概念,并不真实存在。它的主要目的是围绕原子性、可见性和有序性这几种并发问题定义程序中各种变量的访问规则,即关注在虚拟机中...

的组成和运转流程-JVM (运转的概念)

的组成和运转流程-JVM (运转的概念)

思索:JVM由那些部分组成,运转流程是什么? 1.JVM由那些部分组成,运转流程是什么? JVM是什么 好处: 一次性编写,四处运转 智能内存治理,渣滓回收机制...