Compilación JIT y compilación por niveles
Aprenda cómo la JVM interpreta y después compila con JIT los métodos activos, y cómo activar y observar la compilación.
Compilación JIT y compilación por niveles es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.
Intérprete frente a JIT
Al principio, la JVM interpreta el bytecode. Cuando un método se llama con frecuencia (se vuelve «caliente»), el compilador JIT lo compila en código máquina nativo para lograr una ejecución mucho más rápida.
Compilación por niveles (predeterminada desde Java 8)
La compilación por niveles utiliza cinco niveles: T0 (intérprete), T1 (C1 simple), T2 (C1 con perfilado limitado), T3 (C1 con perfilado completo) y T4 (C2 completamente optimizado). Los métodos ascienden de nivel a medida que se vuelven más activos.
// Enable/disable tiered compilation:
// -XX:+TieredCompilation (default ON in Java 8+)
// -XX:-TieredCompilation (disables — only C2 used)Compilador C1 (compilador de cliente)
C1 compila rápidamente con una optimización moderada. Añade instrumentación de perfilado para medir la frecuencia de las llamadas y los resultados de las bifurcaciones para C2.
Compilador C2 (compilador de servidor)
C2 (Opto) realiza optimizaciones profundas: inclusión de métodos, análisis de escape, desenrollado de bucles, vectorización y eliminación de código muerto. Produce el código nativo más rápido, pero tarda más en compilar.
// Force server JIT only:
java -server MyApp
// Or explicitly:
java -XX:-TieredCompilation MyApp // uses C2 only (warm-up is slower)Umbral de actividad
Un método se compila con JIT después de superar un umbral del contador de invocaciones. Valor predeterminado: 10 000 llamadas (C2). Ajústelo con -XX:CompileThreshold=N.
// Lower threshold for faster warm-up (at cost of less optimization):
java -XX:CompileThreshold=1000 MyAppInclusión de métodos
La inclusión de métodos es la optimización más importante de C2: los métodos pequeños llamados desde código activo se «copian y pegan» en el punto de llamada, lo que elimina la sobrecarga del despacho de métodos y permite realizar más optimizaciones.
// Check inlining decisions:
java -XX:+PrintInlining -XX:+UnlockDiagnosticVMOptions MyApp
// Output:
// @ 5 com.example.User::getName (5 bytes) inlinedAnálisis de escape
Si C2 determina que un objeto nunca escapa del método o subproceso actual, puede asignarlo en la pila en lugar de en el montón, eliminando por completo la presión sobre el GC.
// Objects that don't escape are stack-allocated:
String result = new StringBuilder().append("Hello ").append(name).toString();
// The StringBuilder may be eliminated by escape analysisRegistros de compilación JIT
Utilice -XX:+PrintCompilation para registrar cada método cuando se compila. La salida muestra el nombre del método, el nivel y las marcas de compilación.
// java -XX:+PrintCompilation MyApp
// Output:
// 1 n java.lang.String::hashCode (0 bytes)
// 25 3 com.example.UserService::findById (42 bytes)
// 31 4 com.example.UserService::findById (42 bytes) made not entrantDesoptimización
Si se infringe una suposición del JIT (por ejemplo, si se carga una clase que cambia el tipo del receptor en un punto de llamada), C2 se «desoptimiza»: vuelve al intérprete o a C1. Esto es normal y normalmente transparente.
Tiempo de calentamiento
La compilación JIT requiere tiempo. En procesos de corta duración, es posible que los métodos nunca lleguen a compilarse con JIT. Utilice la compilación anticipada (GraalVM Native Image) o almacene en caché los resultados del JIT con Class Data Sharing (CDS) para acelerar el inicio.
// Enable AppCDS to cache JIT-compilable classes:
java -XX:ArchiveClassesAtExit=app.jsa -cp app.jar MyApp # generate archive
java -XX:SharedArchiveFile=app.jsa -cp app.jar MyApp # use archiveJIT de GraalVM
GraalVM sustituye C2 por un JIT escrito en Java. Permite realizar mejores optimizaciones, utilizar JIT con lenguajes distintos de Java y sirve como base para Native Image (compilación anticipada).
Comprobación rápida
Resumen
La compilación por niveles hace avanzar los métodos desde C1 (compilación rápida y perfilado) hasta C2 (optimización profunda). Optimizaciones principales: inclusión de métodos, análisis de escape y desenrollado de bucles. Utilice -XX:+PrintCompilation para observar las decisiones del JIT. Caliente el código antes de realizar comparativas de rendimiento.
Preguntas frecuentes
¿La lección «Compilación JIT y compilación por niveles» es gratis?
Sí — el texto completo de «Compilación JIT y compilación por niveles» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Compilación JIT y compilación por niveles»?
Aprenda cómo la JVM interpreta y después compila con JIT los métodos activos, y cómo activar y observar la compilación. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Java Academy?
No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Compilación JIT y compilación por niveles»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Java Academy?
Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Fases de carga de clases: carga, enlace e inicialización
- Jerarquía de ClassLoader y cargadores personalizados
- Inspección del bytecode con javap
- Compilación JIT y compilación por niveles