JVM por debaixo dos panos #2 - VMproperties e introdução à Memória
Tags: java, tutorial, advanced
Published: 2020-03-17 01:56:21

**:coffee: Esta é minha série de artigos sobre Java Virtual Machine!**

O core da JVM é aquilo que é indispensável de você entender, desde uma configuração simples, até gerenciamento de memória dentro da JVM.

## Entendendo a Virtual Machine na sua IDE

Configurar a VM na sua IDE de desenvolvimento é essencial para que seu código rode de forma que não impacte nada, veremos mais pra frente como tudo por volta da JVM faz com que tudo esteja lidando de forma mais responsiva possível. Então vamos começar de algum lugar, e depois mergulhar mais fundo em memória.

> Dica: É interessante e de suma importância a JVM ser configurada de acordo com a sua IDE, você pode obter essa configuração de diversas maneiras, mas nesse tutorial eu vou ensinar a configuração sendo feita no IntelliJ no Windows 10

#### Configurando o IntelliJ

Nele a maneira mais fácil de alterar as opções da JVM é em:

Ajuda > Edit VM custom options

![tela do IntelliJ com a aba de ajuda selecionada](https://dev-to-uploads.s3.amazonaws.com/i/btkkd5sw4unam86h7dbb.png)

Esta ação vai resultar numa cópia do arquivo .vmproperties, após feito isso no diretório de configuração da sua IDE, você vai ter um documento no editor que pode ser alterado conforme a imagem a seguir:

![arquivo gerado após clicar](https://dev-to-uploads.s3.amazonaws.com/i/pxlnr4rajvwl3uwuvw67.png)

Se você não conseguir fazer pela sua IDE, está tudo bem, abrindo o seu terminal (cmd ou o terminal do linux) , você consegue a edição desse arquivo manualmente com o seguinte comando: 
```
SUA_IDE\bin\<product>[bits][.exe].vmoptions
```

No exemplo abaixo será executado este arquivo no terminal do Windows 10, localizei a pasta onde estava minha IDE (IntelliJ) , e a partir daí eu executei meu **.vmproperties** e então executei o VM options, o caminho pode variar de acordo da pasta que esta salva sua IDE e onde seu código esta sendo editado.

Depois de executado o é redirecionado ao editor de preferência
``` 
idea64.exe.vmoptions
```

![cmd com o idea.exe.vmoptions sendo executado](https://dev-to-uploads.s3.amazonaws.com/i/lo3zjp16flvykalf4hls.png)

Na imagem temos as opções do editor:

![arquivo gerado a partir dele](https://dev-to-uploads.s3.amazonaws.com/i/0a7d9tjc48c5qppa1qrj.png)

As opções são definidas linha por linha, e  você pode configurar da forma que for mais adequada pro seu sistema, a configuração padrão que você pode adquirir é conforme esta abaixo, a mesma disponível no site da [JebBrains ](https://intellij-support.jetbrains.com/hc/en-us/articles/206544869-Configuring-JVM-options-and-platform-properties)com pequenas mudanças que se adequem ao meu sistema.

``` 
-server
-Xms128m
-Xmx512m
-XX:ReservedCodeCacheSize=240m
-XX:+UseConcMarkSweepGC
-XX:SoftRefLRUPolicyMSPerMB=50
-ea
-Dsun.io.useCanonCaches=false
-Djava.net.preferIPv4Stack=true
-XX:+HeapDumpOnOutOfMemoryError
-XX:-OmitStackTraceInFastThrow
-XX:MaxJavaStackTraceDepth=-1
``` 



## As opções mais comuns

Opção   | Descrição
--------- | ------
-Xmx | Limita o tamanho da heap que a JVM pode alocar e executar no IntelliJ. O valor padrão depende da plataforma, se você estiver enfrentando lentidão você pode querer aumentar esse valor, por exemplo, definir ele pra 2048 megabytes, que ficará **-Xmx2048m** . 
-Xms | Especifica a memória inicial alocada pela JVM para executar o IntelliJ. O valor padrão depende da plataforma que você estiver usando, geralmente é definido para cerca de metade da memória máxima permitida (-Xmx), por exemplo, **-Xms1024m** .
-XX : NewRatio | Especifica a razão entre o tamanho da Young Generation e Old Generation. Na maioria dos casos, recomenda-se uma ratio entre 2 e 4. Isso definirá o tamanho da young generation para ser 1/2 a 1/4 da old generation correspondente, o que é até bom quando você muitas vezes está trabalhando num projeto e em apenas um arquivo de cada vez. No entanto, se você esta constantemente abrindo arquivos novos, e alternando entre vários projetos, você pode precisar aumentar a young generation. Neste caso, tente a configuração **--XX:NewRaio=1**, que tornará a young generation tão grande quanto a Old generation, permitindo que seus objetos criados permaneçam na young generation por mais tempo


#### Você deve estar se perguntando o que são esses tais Old Generation, Young Generation e afins, né?

![Mulher idosa com feição de dúvida](https://dev-to-uploads.s3.amazonaws.com/i/g2y4wq7xgg62xostxs9t.jpg)

#### Agora chegamos em um outro nível, onde vamos abordar o gerenciamento de memória, neste artigo vamos ter apenas uma significado do que cada uma é:

Nós próximos artigos veremos mais a fundo .

## Introdução à memória da JVM

Basicamente a JVM é dividida em duas partes: Memória Heap e Non-heap (que também você pode encontrar po Não-heap), Os espaços vistos como Heap e Não-Heap, e em alguns livros ou fontes externas você pode encontrar como Stack também que são endereçamentos de memória. veja na arquitetura abaixo:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/onka7z4hhgok65m59bv5.png)

o significado de cada uma é:

-> **Heap**: é como uma área de alocação dinâmica, onde seu espaço é reservado para guardar as váriaveis e dados que são criados durante a execução do programa.

Basicamento o Heap é todo estruturado e divido em gerações para organizar melhor os objetos que são entregues.


-> **Young Generation** é o tempo de vida mínimo de um objeto, antes do garbage collector passar por essa geração todos ficam alocados aí, e dentro do young generation temos, os seguintes espaços:

-> **Eden**:  como o próprio nome já diz: Eden, ou seja, início, neste espaço ficam alocados os objetos novos, recém criados.  A cada objeto criado, por exemplo, Pessoa ana = new Pessoa ( ); ficaria alocado neste espaço da memória. 

Esta área tende a reter os objetos por pouco tempo, pois dentro de cada execução de um programa muitos destes objetos são criados, então os objetos passam um ciclo de vida curto no Eden.

-> **Survivor Spaces**: depois do Eden estar totalmente ocupado e sem a possibilidade de ter nenhum novo objeto dentro dele, os mesmo passam ao Survivor Spaces, onde a JVM executa uma Garbage Collection (veremos mais a frente sobre o mesmo) que remove os objetos que estão sem referência e uso, a fim de liberar mais memória. Quando os objetos são criados de forma correta e com referência, eles passam do Eden e sobrevivem ao Garbage Collector, sendo movidos para a área de sobrevivência, mas com a esperança de passarem para a próxima.

-> **Old Generation**: basicamente quando não há mais espaço na memóra os objetos ficam alocados na Old Generation.


-> **Permanent Generation**: depois de todo esse ciclo de vida, você chega a geração permanente, é a área definida pela JVM para armazenar as definições de classes

*Vale lembrar que todo esse gerenciamento de memória esta baseado no Java 8*



E ficamos por aqui, acompanhe essa série sobre Java Virtual Machine, no próximo artigo teremos GARBAGE COLLECTIONS


![thank you next, gif do videoclip da ariana grande](https://media.giphy.com/media/MT9MOLJXrXfVvMJ34C/giphy.gif)


Referências:
![Site da JetBrains](https://www.jetbrains.com/help/idea/tuning-the-ide.html)