Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Arquitetura da JVM e como ela funciona

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