Slide 1
Slide 1 text
JVM
vs
GraalVM
Entenda o funcionamento e o que há de
melhor dessas Virtual Machines
@anabneri
Slide 2
Slide 2 text
Agenda:
Processos de Compilamento
O que a JVM faz...
Arquitetura JVM
Memória
Compiladores
WTF is GraalVM?
Exemplos
Compatibilidade
JVM ou GraalVM?
Slide 3
Slide 3 text
Hello ( );
Engenheira de Software no Itaú
Co-Organizadora da @unicorn.tech
Graduanda em ADS pela BandTec Digital School
Meu blog: https://anabneri.github.io/
@anabneri linkedln.com/in/anabeatrizdev/
Slide 4
Slide 4 text
But first WTF is Java?
Slide 5
Slide 5 text
GreenTalk
Star Seven
Oak
Web
Runner
Java!! o/
Slide 6
Slide 6 text
Processos de
compilamento antes da
Java Virtual Machine
Slide 7
Slide 7 text
Vamos entender o que é compilamento...
Assembly
0101010101
0101010011
0100101010
0101010101
0101010101
0100101010
Slide 8
Slide 8 text
Mas esse era um processo complexo demais...
Slide 9
Slide 9 text
Entendeu man? O
processo de
compilamento do Java
é parecido...
Slide 10
Slide 10 text
Observe a “sutil” diferença, rs
JavaC
JVM
JAVA
BYTECO
DE
Slide 11
Slide 11 text
Isso Possibilita que uma gama de linguagens
possam ser rodadas na JVM
Slide 12
Slide 12 text
Isso quer dizer que JVM é uma linguagem
multi-plataforma, roda aonde quiser e quando quiser!!!
Slide 13
Slide 13 text
Entenda como essa parada
toda funciona, com a
arquitetura da JVM
Slide 14
Slide 14 text
No content
Slide 15
Slide 15 text
Claro que tudo isso é salvo
em algum lugar, entenda o
processo de memória
Slide 16
Slide 16 text
Memória
Nova
(Young
Generation)
Espaço de
sobrevivencia
Memória
Velha
Slide 17
Slide 17 text
Memória
Nova
(Young
Generation)
Espaço de
sobrevivencia
Memória
Velha
Garbage Collector
Slide 18
Slide 18 text
Olha ai o Garbage Collector
Slide 19
Slide 19 text
Young
Generation
(NEW)
Survivor
Tenured
(OLD)
Slide 20
Slide 20 text
Mas o que exatamente essas memórias significam?
Grupo Heap e Stack (non-heap)
Heap = Lugar onde
os objetos com
semântica e
referência são
armazenados, e é
referenciado pelo
Garbage Collector
Non-Heap =
Armazenados
objetos curtos e de
pouca duração, é
uma área de
tamanho fixo
semelhante a uma
pilha.
Slide 21
Slide 21 text
Mas o que exatamente essas memórias significam?
Grupo Heap e Stack (non-heap)
Slide 22
Slide 22 text
Mas o que exatamente essas memórias significam?
HEAP STACK
Produto produto = new Produto
Slide 23
Slide 23 text
No content
Slide 24
Slide 24 text
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryUsage;
import java.util.List;
import java.util.Locale;
Slide 25
Slide 25 text
public class Main {
public static int MEGA = 1024 * 1024;
public static String FORMAT = " (%.2fmb)";
….
}
Slide 26
Slide 26 text
//o intellij ja traz os imports automaticamente referente a
memória
MemoryMXBean memoryMXBean =
ManagementFactory.getMemoryMXBean();
out.println(":::::Memória heap:::::");
out.println();
MemoryUsage heapMemory =
memoryMXBean.getHeapMemoryUsage();
Slide 27
Slide 27 text
out.println("Tamanho Inicial :: " + heapMemory.getInit() +
String.format(Locale.US, FORMAT,(double) heapMemory.getInit() / MEGA));
out.println("Tamanho atual :: " +
heapMemory.getInit() +
String.format(Locale.US, FORMAT, (double) heapMemory.getCommitted()
/ MEGA));
out.println("Usado :: " +heapMemory.getUsed() +
String.format(Locale.US, FORMAT, (double) heapMemory.getUsed() / MEGA));
out.println("Máximo :: " + heapMemory.getMax() +
String.format(Locale.US, FORMAT, (double) heapMemory.getMax() / MEGA));
out.println();
Slide 28
Slide 28 text
out.println(":: Pool de memórias Organ. JVM ::");
out.println();
List list =
ManagementFactory.getMemoryPoolMXBeans();
Slide 29
Slide 29 text
for (MemoryPoolMXBean m :list) {
out.println("Nome do Pool :: " + m.getName());
out.println("Grupo ::" + m.getType());
out.println();
}
Slide 30
Slide 30 text
MemoryUsage usage = m.getUsage();
out.println("Inicial: " + usage.getInit() +
String.format(Locale.US, FORMAT, (double) usage.getInit() / MEGA));
out.println("Atual: " +usage.getCommitted() +
String.format(Locale.US, FORMAT, (double) usage.getCommitted() /
MEGA));
out.println("Usado: " + usage.getUsed() +
String.format(Locale.US, FORMAT, (double) usage.getUsed() / MEGA));
out.println("Máximo: " + usage.getMax() +
String.format(Locale.US, FORMAT, (double) usage.getMax() / MEGA));
out.println();
Slide 31
Slide 31 text
Vale lembrar que
as Strings
funcionam
diferente no Java
Slide 32
Slide 32 text
for (int i = 0; true; i++){
String str2 = (str + i).intern();
Slide 33
Slide 33 text
if (i % 100000 == 0) {
MemoryUsage mu = mp.getUsage();
System.out.println("PermGen inicial: " +
String.format(FORMAT, (double) mu.getInit() / MEGA) +
"commitada: " + String.format(FORMAT, (double)
mu.getCommitted() / MEGA) +
"utilizada: " + String.format(FORMAT, (double)
mu.getUsed() / MEGA) +
"Max: " + String.format(FORMAT, (double) mu.getMax() /
MEGA));
}
Slide 34
Slide 34 text
if ( i == 200000){
System.out.println("Retirar a referencia das Strings do
Pool" );
textos = new ArrayList();
}
textos.add(str2);
Slide 35
Slide 35 text
for (MemoryPoolMXBean m : lista){
if ((m.getType() == MemoryType.NON_HEAP)
&& m.getName().toUpperCase().indexOf("METASPACE")
!= -1){
mp = m;
break;
}
}
return mp;
Slide 36
Slide 36 text
Temos também os
Compiladores, que entram
dentro e fora da JVM
também
Slide 37
Slide 37 text
Os compiladores
Slide 38
Slide 38 text
Just in time - JIT
Revolução da JVM
Faz compilação em
modo dinâmico
Verifica quantas vezes
o método esta sendo
executado
A otimização do JIT
faz a JVM ser cada vez
mais rápida!
Slide 39
Slide 39 text
HotsPot - JVM
Esta dentro da JVM, é
como se fosse outra
VM dentro do java pra
otimizar tempo
Utiliza 10% do tempo
para compilar 90% do
código
Utiliza 10% do tempo
para compilar 90% do
código
Os dados são obtidos
através da executção
real do programa
Slide 40
Slide 40 text
Vamos ver toda essa lógica na prática!!!!!
Slide 41
Slide 41 text
No content
Slide 42
Slide 42 text
E se eu disser pra vocês, que
tem como melhorar
Slide 43
Slide 43 text
No content
Slide 44
Slide 44 text
No content
Slide 45
Slide 45 text
E o GraalVM é Open Source!
Vamos entender o mundo do
open source
Slide 46
Slide 46 text
No content
Slide 47
Slide 47 text
const express = require('express');
const app = express();
É poliglota
Slide 48
Slide 48 text
....
var text = 'Hello World!';
const BigInteger = Java.type(
'java.math.BigInteger');
text += BigInteger.valueOf(2)
.pow(100).toString(16);
text += Polyglot.eval(
'R', 'runif(100)')[0];
res.send(text);
})
Slide 49
Slide 49 text
É NATIVO
$ javac HelloWorld.java
$ time java HelloWorld
user 0.070s
$ native-image HelloWorld
$ time ./helloworld
user 0.005s
Slide 50
Slide 50 text
JVM OU GRAALVM QUAL É O MELHOR….
Slide 51
Slide 51 text
Sim eu sei, muita informação
Slide 52
Slide 52 text
Por que é importante você
saber essa parada toda...
> Diferencial no
mercado e na vida
> Profundidade =
excelência
> Argumentos pra quando
alguem diz que Java é ruim
Slide 53
Slide 53 text
CONCLUINDO <3
Slide 54
Slide 54 text
Dúvidas, questionamentos, críticas,
lamentações?
Slide 55
Slide 55 text
Keep in touch
Meu blog: https://anabneri.github.io/
@anabneri
linkedln.com/in/anabeatrizdev/
bit.ly/jvmgraalvm
Slide 56
Slide 56 text
referências
https://www.baeldung.com/java-stack-heap
https://pt.wikipedia.org/wiki/HotSpot
Livro: Mundo Java Efetivo – A casa do Código
https://blog.mandic.com.br/artigos/java-garbage-collection-m
elhores-praticas-tutoriais-e-muito-mais/