Compilação JIT e compilação em camadas
Aprenda como a JVM interpreta e depois compila métodos quentes com JIT, além de como iniciar e observar a compilação.
Compilação JIT e compilação em camadas é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.
Interpretador versus JIT
A JVM inicialmente interpreta o bytecode. Quando um método é chamado com frequência (fica "quente"), o compilador JIT o compila em código de máquina nativo para uma execução muito mais rápida.
Compilação em camadas (padrão desde o Java 8)
A compilação em camadas usa cinco níveis: T0 (interpretador), T1 (C1 simples), T2 (C1 com criação de perfil limitada), T3 (C1 com criação de perfil completa), T4 (C2 totalmente otimizado). Os métodos avançam pelos níveis à medida que ficam mais quentes.
// Enable/disable tiered compilation:
// -XX:+TieredCompilation (default ON in Java 8+)
// -XX:-TieredCompilation (disables — only C2 used)Compilador C1 (compilador cliente)
O C1 compila rapidamente com otimização moderada. Ele adiciona instrumentação de criação de perfil para medir a frequência das chamadas e os resultados dos desvios para o C2.
Compilador C2 (compilador servidor)
O C2 (Opto) realiza otimizações profundas: incorporação de métodos, análise de escape, desenrolamento de laços, vetorização e eliminação de código morto. Ele produz o código nativo mais rápido, mas leva mais tempo para compilar.
// Force server JIT only:
java -server MyApp
// Or explicitly:
java -XX:-TieredCompilation MyApp // uses C2 only (warm-up is slower)Limite de código quente
Um método é compilado pelo JIT depois de ultrapassar um limite do contador de invocações. Padrão: 10.000 chamadas (C2). Ajuste com -XX:CompileThreshold=N.
// Lower threshold for faster warm-up (at cost of less optimization):
java -XX:CompileThreshold=1000 MyAppIncorporação de métodos
A incorporação de métodos é a otimização mais impactante do C2: métodos pequenos chamados por código quente são "copiados e colados" no local da chamada, eliminando a sobrecarga da resolução do método e permitindo otimizações adicionais.
// Check inlining decisions:
java -XX:+PrintInlining -XX:+UnlockDiagnosticVMOptions MyApp
// Output:
// @ 5 com.example.User::getName (5 bytes) inlinedAnálise de escape
Se o C2 determinar que um objeto nunca escapa do método (ou da thread) atual, poderá alocá-lo na pilha em vez do heap — eliminando completamente a pressão sobre o 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 da compilação JIT
Use -XX:+PrintCompilation para registrar cada método à medida que é compilado. A saída mostra o nome do método, o nível e as sinalizações de compilação.
// 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 entrantDesotimização
Se uma suposição do JIT for violada (por exemplo, se uma classe for carregada e alterar o tipo do receptor no local da chamada), o C2 faz uma "desotimização" — retorna ao interpretador ou ao C1. Isso é normal e geralmente transparente.
Tempo de aquecimento
A compilação JIT leva tempo. Em processos de curta duração, os métodos talvez nunca sejam compilados pelo JIT. Use compilação antecipada (GraalVM Native Image) ou armazene os resultados do JIT em cache com o Class Data Sharing (CDS) para acelerar a inicialização.
// 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 do GraalVM
O GraalVM substitui o C2 por um JIT escrito em Java. Ele permite otimizações melhores, o uso de JIT para linguagens que não são Java e serve de base para o Native Image (compilação antecipada).
Verificação rápida
Qual é a técnica de compilação JIT que elimina a sobrecarga da chamada de métodos ao incorporar métodos pequenos no método chamador?
Recapitulação
A compilação em camadas move os métodos do C1 (compilação rápida e criação de perfil) para o C2 (otimização profunda). Principais otimizações: incorporação de métodos, análise de escape e desenrolamento de laços. Use -XX:+PrintCompilation para observar as decisões do JIT. Aqueça o código antes de fazer medições de desempenho.
Perguntas Frequentes
A aula “Compilação JIT e compilação em camadas” é grátis?
Sim — o texto completo de “Compilação JIT e compilação em camadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.
O que vou aprender em “Compilação JIT e compilação em camadas”?
Aprenda como a JVM interpreta e depois compila métodos quentes com JIT, além de como iniciar e observar a compilação. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Compilação JIT e compilação em camadas”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Fases de Carregamento de Classes: Carregar, Vincular e Inicializar
- Hierarquia de ClassLoader e Carregadores Personalizados
- Inspecionando bytecode com javap
- Compilação JIT e compilação em camadas