By compiling before the program executes, the AOT compiler must be conservative about classes, fields, and methods referenced by the code it compiles.
由于在程序执行前进行编译，AOT编译器必须谨慎对待它所编译的代码所引用的类、字段和方法。
AOT-compiled code, on the other hand, starts much higher than interpreted performance but is unlikely to be as high as can be achieved via the JIT compiler.
另一方面，AOT编译代码启动时的性能比解释的性能高很多，但是无法达到JIT编译器所能达到的最高性能。
You can accelerate application start-up by carefully using AOT-compiled code because this code, although typically slower than JIT-compiled code, can be many times faster than interpretation.
可以通过谨慎地使用AOT编译代码加快应用程序启动，因为虽然这种代码通常比JIT编译代码慢，但是却比解释代码快很多倍。
You can build a more optimized set of precompiled JAR files by creating a profile of the methods that your application uses frequently and AOT-compiling only those methods.
您可以构建一组更为优化的预先编译JAR文件，方法是创建一个您的应用程序频繁使用的方法配置文件，然后仅用 AOT 编译这些方法。
Dynamic class loading, which is a challenge for the dynamic JIT compiler, is an even more significant issue for AOT compilation.
动态类加载是动态jit编译器面临的一个挑战，也是AOT编译的一个更重要的问题。
There is no direct footprint benefit because each JVM still has a copy of the AOT executable but there are memory and CPU savings from being able to reuse this code rather than repeat the compilation.
因为每个JVM仍然拥有AOT代码的拷贝，所以这种实现方式对于内存使用量没有直接的好处。但是，由于能够重用 AOT 代码并避免重复编译，可以节省内存和CPU。
We advise you not only to precompile your application, but also to AOT-compile key system JAR files.
我们建议，不仅要预先编译您的应用程序，还要对关键的系统JAR文件进行AOT编译。
You will also learn how to Ahead-of-time (AOT) compile your application for improved determinism in an RT environment.
您还会学习如何预编译(AOT)您的应用程序，以便改进一个RT环境中的确定性。
AOT code must therefore be generated with every static, field, class, and method reference unresolved.
AOT代码因此必须在没有解析每个静态、字段、类和方法引用的情况下生成。
We are principally AOT compiling them to test the AOT compiler.
我们使用AOT编译它们主要是为了测试aot编译器。
The JXEs used to store AOT code are generally much larger than the JAR files that hold the class files because native code is generally less dense than the bytecodes stored in class files.
用于存储AOT代码的JXE 文件通常要比存放类文件的JAR 文件大很多，这是因为本地代码一般要比存储在类文件中的字节码密度小。
AOT compilation makes heuristic decisions to select candidate methods that will improve future startup time.
AOT编译通过启发式决策选择候选方法，这会进一步改进启动速度。
The AOT-compiled code is the equivalent to the native code the JIT compiler would generate if it used a fixed optimisation level.
如果JIT使用了一种固定的优化级别，那么AOT编译的代码就等同于JIT编译器生成的本地代码。
Although AOT code enables more-deterministic performance, it also has some disadvantages.
尽管AOT代码能够产生更确定的性能，它同样具有一些缺点。
In addition, using AOT code from the cache helps reduce startup time.
另外，使用缓存中的AOT代码也有助于减少启动时间。
Rt applications can also derive an important benefit from AOT-compiled code: more-deterministic performance that exceeds interpreted performance.
RT应用程序也能从AOT编译代码中获得重要的收益：更具确定性的性能超过了解释的性能。
Nonetheless, the common case is that AOT-compiled code is slower than JIT-compiled code.
虽然如此，通常aot编译的代码的速度要慢于JIT编译的代码。
Because AOT compilation occurs before the program executes, the compiler can't make any assumptions about which classes have been loaded.
因为是在程序执行前进行AOT编译的，所以编译器无法预测加载了哪些类。
A second disadvantage is that AOT-compiled code, though faster than interpreted code, can be substantially slower than JIT-compiled code.
第二个缺点是，尽管AOT编译过的代码比解释过的代码执行速度快，但是却比JIT编译的代码慢得多。
It then compares and contrasts the two compilation strategies and points out several application areas as well as execution environments where AOT compilation is probably the better approach.
然后比较了这两种编译策略并指出了几种比较适合使用AOT编译的应用程序领域和执行环境。
In a JVM with AOT-compiled code but no JIT compiler, the number of transitions is determined by the set of methods that were compiled into the JXEs.
在具有AOT编译代码而没有JIT编译器的JVM中，转换次数是由被编译到JXE中的方法决定的。
AOT-compiled code, therefore, needs to be bound into the JVM's current execution environment before it can be executed.
因此aot编译代码需要绑定到JVM的当前执行环境中，然后才能执行。
So it's possible that a future invocation of an application may also cause some additional methods to be AOT-compiled.
因此，对应用程序的后续调用可能会导致更多的方法被 AOT 编译。
If you do not specify a maximum amount of AOT code that can be stored, then the default setting is to use the entire cache.
如果没有指定可以存储的AOT代码最大量，默认设置是使用整个缓存。
Moreover, more methods can be AOT compiled than a JIT compiler might decide to compile, which can also result in better performance with AOT compilation than JIT compilation.
此外，AOT能够比JIT编译器编译更多的方法，因此aot编译也能比JIT编译产生更好的性能。
Once you have AOT-compiled your application, you can use this command to run it.
对您的应用程序进行了AOT编译之后，就可以使用此命令来运行它了。
The compiler doesn't blindly compile everything though I think it can be deployed as an ahead-of-time (AOT) compiler. It kicks in whenever method execution counters trip over some threshold.
虽然我认为可以将编译器部署为AOT（ahead-of-time）编译器，但它其实并不会盲目地编译所有东西，只有当方法执行计数器超过某个阈值时它才会生效。
Since participants in AoT events come from all over the world, travel is always an issue, not just because of the expenses, but also the travel time.
由于AoT活动的参与者来自世界各地，旅行总是一个问题，不只是由于旅行费用，还在于旅行时间问题。
Note that AOT compilations are performed at a cold optimization level, which reflects the overall AOT goal to accelerate application startup.
注意，AOT编译以 cold优化级别执行，这反映 AOT的总体目标是加快应用程序的启动。
Default JIT compilation at low priority with Ahead-of-time (AOT) compiled code used initially.
较低优先级上的默认JIT编译，在最初使用了提前(Ahead - of - time,AOT)编译代码。
应用推荐