JIT编译器在程序启动后运行，并实时(或称为just-in-time)将代码(通常是字节码或某种虚拟机指令)编译为通常更快的形式，通常是主机CPU的本机指令集。JIT可以访问动态运行时信息，而标准编译器不能，并且可以进行更好的优化，例如经常使用的内联函数。

这与传统的编译器相反，传统的编译器在程序第一次运行之前将所有代码编译为机器语言。

换句话说，在你第一次运行程序之前，传统的编译器会将整个程序构建为一个EXE文件。对于新样式的程序，程序集是用伪代码(p-code)生成的。只有在你在操作系统上执行程序之后(例如，通过双击它的图标)，(JIT)编译器才会启动并生成基于英特尔处理器或其他能够理解的机器代码(m-code)。

代码被编译成某种IL(中间语言)。当你运行你的程序时，计算机不理解这段代码。它只理解本机代码。因此JIT编译器会动态地将IL编译为本地代码。它在方法级别上执行此操作。

JIT代表Just-in-Time，这意味着代码在需要时才编译，而不是在运行时之前。

这是有益的，因为编译器可以生成针对特定机器优化的代码。静态编译器，就像普通的C编译器一样，将所有代码编译为开发人员机器上的可执行代码。因此，编译器将基于一些假设执行优化。它可以编译得更慢，做更多的优化，因为它不会降低用户执行程序的速度。

一开始，编译器负责将高级语言(定义为比汇编程序更高级别)转换成目标代码(机器指令)，然后(通过链接器)将其链接成可执行文件。

At one point in the evolution of languages, compilers would compile a high-level language into pseudo-code, which would then be interpreted (by an interpreter) to run your program. This eliminated the object code and executables, and allowed these languages to be portable to multiple operating systems and hardware platforms. Pascal (which compiled to P-Code) was one of the first; Java and C# are more recent examples. Eventually the term P-Code was replaced with bytecode, since most of the pseudo-operations are a byte long.

即时(JIT)编译器是运行时解释器的一个特性，它不是在每次调用方法时都解释字节码，而是将字节码编译为运行机器的机器代码指令，然后调用此目标代码。理想情况下，运行目标代码的效率将克服每次运行时重新编译程序的低效率。

非jit编译器获取源代码，并在编译时将其转换为特定于机器的字节代码。JIT编译器获取编译时生成的与机器无关的字节代码，并在运行时将其转换为特定于机器的字节代码。Java使用的JIT编译器允许一个二进制文件无需修改就能在多种平台上运行。

在Java编译器生成字节代码(与体系结构无关)之后，执行将由JVM(在Java中)处理。字节代码将由加载器加载到JVM中，然后解释每个字节指令。

当我们需要多次调用一个方法时，我们需要多次解释相同的代码，这可能会花费更多的时间。所以我们有了JIT(即时)编译器。当字节被加载到JVM(它的运行时)中时，整个代码将被编译而不是解释，从而节省时间。

JIT编译器只在运行时工作，所以我们没有任何二进制输出。

jit——来得正是时候 这个词本身就表示需要的时候(按需)

典型场景:

源代码完全转换为机器代码

JIT的场景:

源代码将转换为汇编语言，如结构[为ex IL(中间语言)为c#，字节码为java]。

中间代码仅在应用程序需要时才转换为机器语言，所需代码仅转换为机器代码。

JIT与非JIT的比较:

在JIT中，并不是所有的代码都先转换成机器码 所有必要的代码都将被转换成机器代码 如果调用的方法或功能不在机器中，那么 将被转换成机器代码…减少CPU的负担。 因为机器代码将在运行时....上生成JIT 编译器将生成优化运行的机器代码 机器的CPU架构。

JIT的例子:

在Java中，JIT是在JVM (Java虚拟机)中 在c#中，它是在CLR(公共语言运行库)中 在Android中，它是在DVM (Dalvik Virtual Machine)中，或者在更新的版本中是ART (Android RunTime)。

正如其他人提到的

JIT代表Just-in-Time，这意味着代码在需要时才编译，而不是在运行时之前。

为了给上面的讨论补充一点，JVM维护一个函数执行时间的计数。如果该计数超过预定义的限制，JIT将代码编译为处理器可以直接执行的机器语言(不像一般情况下，javac将代码编译为字节码，然后java -解释器逐行解释这个字节码，将其转换为机器代码并执行)。

另外，下次计算此函数时，将再次执行相同的编译代码，而不像常规解释那样逐行重新解释代码。这使得执行速度更快。

我知道这是一个老线程，但是运行时优化是JIT编译的另一个重要部分，这里似乎没有讨论它。基本上，JIT编译器可以在程序运行时监视它，以确定改进执行的方法。然后，它可以在运行时动态地进行这些更改。谷歌JIT优化(javaworld有一篇关于它的很好的文章。)

Jit代表即时编译器 Jit是一个将Java字节代码转换为可以直接发送到处理器的指令的程序。

在特定的系统平台上使用java即时编译器(实际上是第二个编译器)将字节码遵从为特定的系统代码，一旦代码被jit编译器重新编译，它通常会在计算机中运行得更快。

即时编译器随虚拟机一起提供，可选使用。它将字节码编译为立即执行的特定于平台的可执行代码。

20%的字节码在80%的时间内被使用。JIT编译器获得这些统计数据，并优化这20%的字节代码，通过添加内联方法、删除未使用的锁等，并创建特定于这台机器的字节码来更快地运行。我引用这篇文章，我发现它很方便。http://java.dzone.com/articles/just-time-compiler-jit-hotspot

JIT指的是一些JVM实现中的执行引擎，它更快，但需要更多内存，是一种即时编译器。在此方案中，方法的字节码在第一次调用方法时被编译为本机机器码。然后缓存该方法的本机机器码，以便下次调用相同的方法时可以重用它。

JVM actually performs compilation steps during runtime for performance reasons. This means that Java doesn't have a clean compile-execution separation. It first does a so called static compilation from Java source code to bytecode. Then this bytecode is passed to the JVM for execution. But executing bytecode is slow so the JVM measures how often the bytecode is run and when it detects a "hotspot" of code that's run very frequently it performs dynamic compilation from bytecode to machinecode of the "hotspot" code (hotspot profiler). So effectively today Java programs are run by machinecode execution.

Just In Time编译器: 它将java字节码编译成特定CPU的机器指令。

例如，如果我们在java代码中有一个循环语句:

while(i<10){
    // ...
    a=a+i;
    // ...
 }

如果i的值为0，上述循环代码将运行10次。

没有必要一次又一次地编译字节码10次，因为相同的指令将执行10次。在这种情况下，只需要编译该代码一次，并且可以将值更改所需的次数。因此，Just In Time (JIT) Compiler会跟踪这些语句和方法(如上所述)，并将这些字节代码片段编译为机器代码以获得更好的性能。

另一个类似的例子是在字符串/句子列表中使用“正则表达式”搜索模式。

JIT Compiler不会将所有代码编译为机器代码。它在运行时编译具有类似模式的代码。

请参阅了解JIT的Oracle文档以了解更多信息。

JIT编译器只在第一次执行时将字节码编译为等效的本机代码。在每次连续执行时，JVM仅使用已编译的本机代码来优化性能。

如果没有JIT编译器，JVM解释器将逐行转换字节码，使其看起来就像正在执行本机应用程序一样。

源

即时(JIT)编译(也称为动态翻译或运行时编译)是一种执行计算机代码的方式，它涉及在程序执行期间(在运行时)而不是在执行之前进行编译。

IT编译结合了两种传统的机器代码转换方法——预先编译(AOT)和解释，并结合了两者的一些优点和缺点。JIT编译结合了编译代码的速度和解释的灵活性。

让我们考虑在JVM中使用的JIT，

例如，HotSpot JVM JIT编译器生成动态优化。换句话说，它们在Java应用程序运行时做出优化决策，并生成针对底层系统架构的高性能本机机器指令。

When a method is chosen for compilation, the JVM feeds its bytecode to the Just-In-Time compiler (JIT). The JIT needs to understand the semantics and syntax of the bytecode before it can compile the method correctly. To help the JIT compiler analyze the method, its bytecode are first reformulated in an internal representation called trace trees, which resembles machine code more closely than bytecode. Analysis and optimizations are then performed on the trees of the method. At the end, the trees are translated into native code.

跟踪树是在编程代码的运行时编译中使用的数据结构。跟踪树用于一种“即时编译器”，它跟踪在热点期间执行的代码并编译它。提到这一点。

参考:

http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html https://en.wikipedia.org/wiki/Just-in-time_compilation

即时编译器(JIT)是一种软件，它接收一个不可执行的输入，并返回要执行的适当机器代码。例如:

Intermediate representation    JIT    Native machine code for the current CPU architecture

     Java bytecode            --->        machine code
     Javascript (run with V8) --->        machine code

其结果是，对于特定的CPU体系结构，必须安装适当的JIT编译器。

区别编译器、解释器和JIT

虽然在一般情况下，当我们想要将源代码转换为机器码时可能会有例外，但我们可以使用:

Compiler: Takes source code and returns a executable Interpreter: Executes the program instruction by instruction. It takes an executable segment of the source code and turns that segment into machine instructions. This process is repeated until all source code is transformed into machine instructions and executed. JIT: Many different implementations of a JIT are possible, however a JIT is usually a combination of a compiler and an interpreter. The JIT first turn intermediary data (e.g. Java bytecode) which it receives into machine language via interpretation. A JIT can often measures when a certain part of the code is executed often and the will compile this part for faster execution.

Just In Time编译器也称为JIT编译器 Java的性能改进。默认启用。它是 编译在执行时完成。 Java通过将JIT编译器包含在 JVM。