Ferramenta de linha de comandos para encontrar o tamanho e memória de Heap Java usados (Linux)?
Existe uma ferramenta de linha de comandos (Linux) para verificar o tamanho do Heap (e a memória usada) de uma aplicação Java?
Já tentei o jmap. Mas dá informações. sobre áreas de memória interna como Eden/PermGen etc. o que não me é útil. Estou à procura de algo do género: Memória máxima: 1GBMemória Min: 256 MB
Memória de Heap: 700 MB
Memória utilizada: 460 MB Só isso. Eu sei que posso ver isso em JConsole etc., mas eu preciso de uma ferramenta de linha de comando (não pode activar o JMX etc.)
alguma dessas ferramentas / comandos?
13 answers
Cada processo Java tem um pid, que primeiro precisa de encontrar com o comando jps.
Uma vez que você tem o pid, você pode usar {[[2]} para encontrar estatísticas do comportamento do monte de lixo coletado.
jstat -gccapacity [insert-pid-here]irá apresentar informações sobre a geração de reservas de memória e capacidades espaciais.jstat -gcutil [insert-pid-here]apresentará a utilização de cada geração em percentagem da sua capacidade. Útil para obter uma vista de relance de uso.
Veros documentos da jstat no site da Oracle.
O Jvmtop é uma ferramenta de linha de comandos que oferece uma vista ao vivo em várias métricas, incluindo heap.
Exemplo de saída do modo de visão geral da VM:
JvmTop 0.3 alpha (expect bugs) amd64 8 cpus, Linux 2.6.32-27, load avg 0.12
http://code.google.com/p/jvmtop
PID MAIN-CLASS HPCUR HPMAX NHCUR NHMAX CPU GC VM USERNAME #T DL
3370 rapperSimpleApp 165m 455m 109m 176m 0.12% 0.00% S6U37 web 21
11272 ver.resin.Resin [ERROR: Could not attach to VM]
27338 WatchdogManager 11m 28m 23m 130m 0.00% 0.00% S6U37 web 31
19187 m.jvmtop.JvmTop 20m 3544m 13m 130m 0.93% 0.47% S6U37 web 20
16733 artup.Bootstrap 159m 455m 166m 304m 0.12% 0.00% S6U37 web 46
Este comando mostra os tamanhos de heap configurados em 'bytes'.
java -XX:+PrintFlagsFinal -version | grep HeapSize
java -XX:+PrintFlagsFinal -version | grep -iE 'HeapSize|PermSize|ThreadStackSize'
Para As Janelas:
java -XX:+PrintFlagsFinal -version | findstr /i "HeapSize PermSize ThreadStackSize"
Para Mac
java -XX:+PrintFlagsFinal -version | grep -iE 'heapsize|permsize|threadstacksize'
O resultado de todos estes comandos assemelha-se ao resultado abaixo:
uintx InitialHeapSize := 20655360 {product}
uintx MaxHeapSize := 331350016 {product}
uintx PermSize = 21757952 {pd product}
uintx MaxPermSize = 85983232 {pd product}
intx ThreadStackSize = 1024 {pd product}
java version "1.7.0_05"
Java(TM) SE Runtime Environment (build 1.7.0_05-b05)
Java HotSpot(TM) 64-Bit Server VM (build 23.1-b03, mixed mode)
Para encontrar o tamanho em MB, divida o valor com (1024 * 1024).
Sem usar o JMX, que é o que a maioria das ferramentas usa, tudo o que pode fazer é usar
jps -lvm
E inferir que a configuração será a partir das opções da linha de comandos.
Você não pode obter informações dinâmicas sem JMX por padrão, mas você poderia escrever o seu próprio serviço para fazer isso.
BTW: prefiro usar VisualVM em vez de JConsole.
Existe uma ferramenta de linha de comandos com um aspecto visual - jvm-mon . É uma ferramenta de monitorização JVM para a linha de comandos que desaplys:
- Uso do heap, tamanho e máximo
- processos jvm
- utilização do cpu e do GC
- tópicos de topo
As métricas e gráficos actualizam-se enquanto a ferramenta está aberta.
Amostra: 
- Goto GitHub project and download the jpsstat.sh ficheiro
- carregue com o botão direito em jpsstat.sh e gotopermissões tab e torná-lo executável
- execute agora o programa com o seguinte comando ./jpsstat.sh
Aqui está o resultado da amostra do script -
===== ====== ======= ======= =====
PID Name CurHeap MaxHeap %_CPU
===== ====== ======= ======= =====
2777 Test3 1.26 1.26 5.8
2582 Test1 2.52 2.52 8.3
2562 Test2 2.52 2.52 6.4
Em termos de tamanho de heap Java, no Linux, você pode usar
ps aux | grep java
Ou
ps -ef | grep java
E procurar por-Xms, - Xmx para descobrir o tamanho inicial e máximo de heap especificado.
No entanto, se-Xms ou-Xmx estiver ausente para o processo Java em que está interessado, significa que o seu processo Java está a usar os tamanhos de heap predefinidos. Você pode usar o seguinte comando para descobrir os tamanhos padrão.
java -XX:+PrintFlagsFinal -version | grep HeapSize
Ou uma determinada jvm, por exemplo,
/path/to/jdk1.8.0_102/bin/java -XX:+PrintFlagsFinal -version | grep HeapSize
And look for InitialHeapSize e MaxHeapSize, que está em bytes.
Primeiro obter o id do processo, o primeiro número do processo listado, a partir de um dos seguintes: (ou apenas usar ps aux | grep java, se preferir que)
jps -lvm
Então use o ID do processo aqui:
jmap -heap $MY_PID 2>/dev/null | sed -ne '/Heap Configuration/,$p';
jmap -permstat $MY_PID
Qualquer abordagem deve dar-te aproximadamente o mesmo número. É sempre uma boa idéia alocar o heap usando -X..m -X..x para todas as gerações. Você pode, então, garantir e também fazer ps para ver quais parâmetros foram passados e, portanto, ser usado.
Para as utilizações actuais da memória, poderá comparar aproximadamente VIRT (atribuído e partilhado) e RES (usado de facto) com os valores jstat também:
Para Java 8, ver jstat para estes valores, na verdade, significa. Assumindo que corres um simples classe sem mmap ou processamento de ficheiros.
$ jstat -gccapacity 32277
NGCMN NGCMX NGC S0C S1C EC OGCMN OGCMX OGC OC MCMN MCMX MC CCSMN CCSMX CCSC YGC FGC
215040.0 3433472.0 73728.0 512.0 512.0 67072.0 430080.0 6867968.0 392704.0 392704.0 0.0 1083392.0 39680.0 0.0 1048576.0 4864.0 7225 2
$ jstat -gcutil 32277
S0 S1 E O M CCS YGC YGCT FGC FGCT GCT
6.25 0.00 7.96 18.21 98.01 95.29 7228 30.859 2 0.173 31.032
Max :
NGCMX + S0C + S1C + EC + OGCMX + MCMX + CCSMX
3433472 + 512 + 512 + 67072 + 6867968 + 1083392 + 1048576 = 12 GB
(aproximadamente perto e abaixo da memória VIRT)
Max (Min, Usado):
215040 + 512 + 512 + 67072 + 430080 + 39680 + 4864 = ~ 1GB
(aproximadamente perto da memória RES)
"não me cites nisto" mas VIRT mem está aproximadamente perto ou mais do que a memória máxima atribuída, mas desde que a memória a ser usada esteja livre / disponível na memória física, o JVM não abre excepção à memória. Na verdade, max memory não é até comparei com a memória física no arranque da JVM, mesmo com a troca no SO. Uma melhor explicação do que a memória Virtual realmente usada por um processo Java é discutida aqui .
Se usar o jrockit tente a ferramenta da linha de comandos jrcmd. Por exemplo:
$ jrcmd 5127 print_memusage
5127:
Total mapped 1074596KB (reserved=3728KB)
- Java heap 786432KB (reserved=0KB)
- GC tables 26316KB
- Thread stacks 13452KB (#threads=34)
- Compiled code 9856KB (used=9761KB)
- Internal 840KB
- OS 15036KB
- Other 146632KB
- Java class data 75008KB (malloced=74861KB #103221 in 18709 classes)
- Native memory tracking 1024KB (malloced=102KB #8)
Para mais comandos, como o heap_ Diagnostics, use o "jrcmd help" para listá-los.
Https://blogs.oracle.com/jrockit/entry/why_is_my_jvm_process_larger_t
Usar o comando top é a forma mais simples de verificar o uso da memória do programa. RES a coluna mostra a memória física real que é ocupada por um processo.
RES atingiu o valor definido na opção -Xmx. Então, aumentando a memória usando a opção -Xmx tudo correu bem.
jstat -gccapacity javapid (ex. stat -gccapacity 28745)
jstat -gccapacity javapid gaps frames (ex. stat -gccapacity 28745 550 10 )
Amostra O / P do comando acima
NGCMN NGCMX NGC S0C
87040.0 1397760.0 1327616.0 107520.0
NGCMN Minimum new generation capacity (KB).
NGCMX Maximum new generation capacity (KB).
NGC Current new generation capacity (KB).
Obtenha mais detalhes sobre isto em http://docs.oracle.com/javase/1.5.0/docs/tooldocs/share/jstat.html