Arquitetura da JVM e como ela funciona

Transcript

1. Arquitetura da JVM e como ela funciona Kamila Santos Oliveira
2. Quem sou eu Backend Developer na Ame Digital Microsoft MVP em Developer Technologies Book co-author Community organizer
3. Agenda 1. O que é a JVM 2. Como ela funciona 3. Class Loader 4. JVM Memory 5. Method area 6. Heap 7. JVM Language stacks
4. Agenda 8. PC Registers 9. Native Method stacks 10. Execution Engine 11. Interpreter 12. Just in Time Compiler
5. Agenda 13. Garbage Collector 14. Native Method Interfaces 15. Native Method Libraries 16. Java Compilation and execution
6. O que é a JVM? Jvm é o core do ecossistema Java e faz com que os aplicativos baseados em Java (outras linguagens que também usam o JVM) sigam a frase "escreva uma vez, execute em qualquer lugar". Com a JVM, o código escrito em uma máquina pode ser executado em outra que usa a JVM.
7. Como é seu funcionamento? -> O código Java é compilado em bytecode. -> é interpretado em máquinas diferentes -> Bytecode é uma linguagem intermediária entre o sistema host e o código-fonte Java.
8. how it works? Image de: https://www.guru99.com/java-virtual-machine-jvm.html
9. Class Loader Class Loader é responsável por 3 atividades: • Loading • Linking • Initialization
10. Class Loader Quando você compila um arquivo java, ele é convertido em bytecode (arquivo .class). Quando você tenta usar esta classe em seu aplicativo, o class loader o carrega na memória principal.
11. Class Loader - Loading Normalmente, a primeira classe a ser carregada na memória é a classe principal (que contém o método principal). Jvm armazena as seguintes informações no method area:
12. Class Loader - Loading 1. O nome da classe carregada e sua classe pai. 2. Todos os arquivos .class relacionados a esta classe 3. Modificadores, Métodos e Variáveis. Temos 3 carregadores de classes integrados disponíveis em Java:
13. Class Loader - Loading Bootstrap class loader: O carregador de classes raiz. É a superclasse do Extension Class Loader e carrega os pacotes Java padrão (lang, util, net, io ..). Esses pacotes padrão estão presentes no arquivo rt.jar e em outras bibliotecas centrais no diretório $ JAVA_HOME / jre / lib.
14. Class Loader - Loading Extension Class Loader: é a subclasse do Bootstrap Class Loader e a superclasse do Application Class Loader. Carrega as extensões das bibliotecas Java padrão presentes no diretório $ JAVA_HOME / jre / lib / ext
15. Class Loader - Loading Application Class Loader: O último class loader e a subclasse do Extension Class Loader. Carrega os arquivos presentes no caminho de classe. O caminho de classe é definido como o diretório atual do aplicativo.
16. Class Loader - Loading A JVM usa o método ClassLoader.loadClass () para carregar a classe na memória. Tenta carregar a classe com base em um nome totalmente qualificado.
17. Class Loader - Loading Se um class loader pai não puder localizar uma classe, delega o trabalho a um class loader filho. Se o filho não for capaz de carregar a classe, ele lança noClassDefFoundError ou ClassNotFoundException.
18. Class Loader - Linking Depois que uma classe é carregada na memória, ela vai para o processo de linking . O processo de linking envolve combinar os diferentes elementos e dependências do programa.
19. Class Loader - Linking Linking inclui as seguintes etapas: 1. Verificação 2. Preparação 3. Resolução
20. Class Loader - Linking Verificação: Verifica se um arquivo está corretamente formatado e se foi gerado por compilador válido ou não. Se essa verificação falhar, nós recebemos uma runtime exception java.lang.VerifyError. Essa verificação é feita pelo componente ByteCodeVerifier. Quando essa atividade é concluída a classe está pronta para compilação.
21. Class Loader - Linking Preparação: JVM aloca memória para variáveis de classe e inicializa a memória para valores padrão.
22. Class Loader - Linking Resolução: O processo de substituição de referências simbólicas, o processo é feito pesquisando no method area para alocar a entidade de referência.
23. Class Loader - Initialization Nesta etapa, todas as variáveis estáticas são atribuídas com seus valores definidos no código e no bloco estático. Esta etapa é executada de cima para baixo em uma classe de pai para filho na hierarquia de classes.
24. Class Loader - Initialization Image from: https://www.geeksforgeeks.org/jvm-works-jvm-architecture/
25. JVM Memory Nós temos 5 componentes nessa area: • Method area • Heap • JVM language stacks • PC registers • Native Method stacks
26. JVM Memory - Method Area Todos os dados de nível de classe como o pool de constantes de tempo de execução, , dados de método e código para métodos e construtores são armazenados nesta área.
27. JVM Memory - Method Area Se a memória disponível nesta área não for suficiente para a inicialização do aplicativo, a JVM lança um OutOfMemoryError.
28. JVM Memory - Method Area Existe apenas uma área de método por JVM e é um recurso compartilhado.
29. JVM Memory - Heap Area Aqui estão todos os objetos, suas variáveis de instância e matrizes relacionadas. Esta memória é compartilhada por vários threads.
30. JVM Memory - JVM language Stacks Quando uma nova thread é criada na JVM, uma pilha de tempo de execução separada também é criada neste momento.
31. JVM Memory - JVM language Stacks Variáveis locais, chamadas de método e resultados parciais são armazenados aqui.
32. JVM Memory - JVM language Stacks Um stackOverFlowError ocorre quando um processo que está sendo executado em uma thread requer um tamanho de pilha muito grande que não está disponível.
33. JVM Memory - JVM language Stacks Para cada chamada de método, uma entrada é feita na pilha de memória (stack frame) quando essa chamada de método é concluída, a stack frame é destruído.
34. JVM Memory - JVM language Stacks A stack frame é dividida em 3 partes: • Local Variables • Operand stack • Frame Data
35. JVM Memory - JVM language Stacks • Local Variables: cada frame contém um array de variáveis chamado local variables. Todas local variables e seus valores são armazenados aqui. No tempo de compilação o tamanho desse array é determinado.
36. JVM Memory - JVM language Stacks • Operand stack: Cada frame contém uma pilha LIFO chamada operand stack. Atua como um workspace em tempo de execução para performar operações intermediárias.
37. JVM Memory - JVM language Stacks • Frame Data: Armazena todos os símbolos correspondentes ao method area e armazena as informações do bloco catch em caso de exceptions.
38. PC (Program Counter) Registers Cada thread tem o seu próprio PC registers para armazenar o endereço do que está sendo executado no momento na JVM.
39. JVM Memory - PC (Program Counter) Registers Quando a instrução é executada, o PC register é atualizado com a próxima instrução.
40. JVM Memory - Native Method Stacks Para cada nova thread, uma nova native method stack é alocada.
41. Execution Engine Na execution engine nós temos 3 partes: • Interpreter • Just-In-Time Compiler(JIT) • Garbage Collector
42. Execution Engine • A execution engine executa os bytecodes (arquivo .class) • Lê o bytecode linha a linha • Então usa os dados e informação presentes na área de memória para executar instruções.
43. Execution Engine - Interpreter O interpreter é responsável por ler e executar o bytecode linha a linha. Devido a esse processo linha a linha o interpreter é uma das etapas mais demoradas.
44. Execution Engine - Interpreter Quando um método é chamado múltiplas vezes,a cada vez é necessário uma nova interpretação.
45. Execution Engine - JIT Compiler Nessa etapa, os pontos negativos de demora do interpreter são “compensados”. Porque, a execution engine primeiro usa o interpreter para executar o bytecode e quando acha algum código repetido, usa o JIT compiler.
46. Execution Engine - JIT Compiler JIT compila todo o bytecode e converte para código de imagem nativa. Então, esse código nativo é usado para repetir chamada de métodos, que melhora a performance.
47. Execution Engine - JIT Compiler JIT tem 4 componentes: • Intermediate Code Generator • Code Optimizer • Target Code Generator • Profiler
48. Execution Engine - JIT Compiler O intermediate code generator é responsável por gerar o código intermediário
49. Execution Engine - JIT Compiler O code optimizer é responsável por otimizar o código para uma performance melhor.
50. Execution Engine - JIT Compiler O target code generator é responsável por converter código intermediário para código de máquina nativo.
51. Execution Engine - JIT Compiler Profiler é responsável por encontrar os hotspots (uma das tecnologias que a JVM utiliza para detectar pontos quentes da sua aplicação: código que é executado muito)
52. Execution Engine - Garbage Collector O Garbage Collector (GC) é responsável por coletar e remover objetos não referenciados do heap. Esse processo recupera a memória de tempo de execução automaticamente destruindo eles.
53. Execution Engine - Garbage Collector Esse processo tem 2 etapas: • Mark: O GC identifica os objetos não utilizados na memória. • Sweep: O GC remove os objetos identificados no passo anterior.
54. Execution Engine - Garbage Collector GC é executado automaticamente pela JVM em intervalos regulares mas também pode ser disparado chamando System.gc ()
55. Execution Engine - Garbage Collector Nós temos 3 tipos de GC: • Serial GC • Parallel GC • Garbage First (G1) GC
56. Execution Engine - Garbage Collector Serial GC: é destinado para aplicações pequenas que executam em ambiente single-thread,é a implementação mais simples do GC. O argumento da JVM para usar o Serial Garbage Collector é -XX:+UseSerialGC
57. Execution Engine - Garbage Collector Parallel GC: é o tipo default de GC da JVM. Usa múltiplas threads para garbage collection, mas permanece pausado quando a aplicação está em execução. O argumento da JVM para usar o Parallel Garbage Collector é -XX:+UseParallelGC.
58. Execution Engine - Garbage Collector Garbage First (G1): recomendado para aplicações multi-thread que tem grande espaço de heap disponível.A heap é dividida em espaços de tamanho iguais, G1 identifica as regiões com maior “lixo” e faz a coleta nessa região primeiro.
59. Execution Engine - Garbage Collector O argumento da JVM para usar o G1 Garbage Collector é -XX:+UseG1GC
60. Native Method Interfaces É uma interface (como uma ponte) Que interage com as Native Method Libraries e provem as native libraries (C, C++).
61. Native Method Interfaces Isso permite que a JVM chame bibliotecas C/C++ e seja chamada por bibliotecas C/C++
62. Native Method Interfaces Usando a palavra chave native você pode indicar que aquela implementação de método foi provida por uma biblioteca nativa, você precisa invocar o método System.loadLibrary() para carregar essa biblioteca nativa compartilhada na memória ,e torna essas funções disponíveis em Java.
63. Native Method Libraries São bibliotecas que são escritas em outras linguagens de programação (como assembly, C e C++). Essas bibliotecas geralmente estão presentes na forma de arquivos .dll ou .so.
64. Java compilation and execution Image From: https://www.guru99.com/java-virtual-machine-jvm.html
65. • Na classe main temos dois métodos f1 e f2 • O método main estaria na classe 1 • O método f1 é armazenado no arquivo a2.java • O método f2 é armazenado no arquivo a2.java
66. • O compilador vai compilar esses três arquivos e produzir 3 arquivos correspondentes .class que consistem em arquivos de bytecode.
67. Java compilation and execution Image From: https://www.guru99.com/java-virtual-machine-jvm.html
68. • A JVM reside na memória RAM da nossa máquina, durante a execução, utilizando o class loader os arquivos são trazidos para a memória RAM
69. • Depois disso o bytecode é verificado para garantir que não tenha nenhuma security branch.
70. Java compilation and execution Image From: https://www.guru99.com/java-virtual-machine-jvm.html
71. • Na última etapa, a execution engine converte o bytecode para código de máquina nativo, isso em tempo de execução.
72. Por que Java é linguagem interpretada e compilada? Um compilador é um programa que converte um programa de um nível de linguagem para outro.
73. Por que Java é linguagem interpretada e compilada? O nosso compilador java converte o código java de alto nível em bytecode (que é código de máquina)
74. Por que Java é linguagem interpretada e compilada? Já um intérprete é um programa que converte um programa de um nível para outra linguagem de programação do mesmo nível. Por exemplo: conversão de programa Java em C ++
75. Por que Java é linguagem interpretada e compilada? No Java, o Just In Time Code generator converte esse bytecode em código de máquina nativo que está nos mesmos níveis de programação.
76. Por que Java é linguagem interpretada e compilada? Sendo assim, Java é compilado e interpretado :)
77. References: https://www.freecodecamp.org/news/jvm-tutor ial-java-virtual-machine-architecture-expla ined-for-beginners/ https://www.geeksforgeeks.org/jvm-works-jvm -architecture/ https://www.guru99.com/java-virtual-machine -jvm.html
78. Thanks :) https://www.linkedin.com/in/kamila-san tos-oliveira/ https://twitter.com/kamilah_santos