사용 된 Java 힙 크기 및 메모리를 찾는 명령 줄 도구 (Linux)?

사용 된 Java 힙 크기 및 메모리를 찾는 명령 줄 도구 (Linux)?

---

Java 응용 프로그램의 힙 크기 (및 사용 된 메모리)를 확인하는 명령 줄 도구 (Linux)가 있습니까?

jmap을 시도했습니다. 그러나 그것은 정보를 제공합니다. Eden / PermGen 등과 같은 내부 메모리 영역에 대해서는 유용하지 않습니다.

: 내가 좋아하는 뭔가를 찾고
최대 메모리 : 1기가바이트
최소 메모리 : 2백56메가바이트
힙 메모리 : 700메가바이트
사용 된 메모리 460 MB의

그게 다야. JConsole 등에서 이것을 볼 수 있지만 명령 줄 도구가 필요합니다 (JMX 등을 활성화 할 수 없음).

그러한 도구 / 명령이 있습니까?

---

각 Java 프로세스에는가 있으며이 명령 pid을 먼저 찾아야합니다 jps.

pid가 있으면 jstat -gc [insert-pid-here]가비지 수집 힙의 동작 통계를 찾는 데 사용할 수 있습니다 .

• jstat -gccapacity [insert-pid-here] 메모리 풀 생성 및 공간 기능에 대한 정보를 제공합니다.

• jstat -gcutil [insert-pid-here]각 세대의 사용률을 용량의 백분율로 표시합니다. 사용량을 한눈에 파악하는 데 유용합니다.

Oracle 사이트의 jstat 문서 를 참조하십시오 .

---

jvmtop 은 힙을 포함한 여러 메트릭에서 라이브 뷰를 제공하는 명령 줄 도구입니다.

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

---

이 명령은 구성된 힙 크기를 바이트 단위로 표시합니다.

java -XX:+PrintFlagsFinal -version | grep HeapSize

EC2의 Amazon AMI에서도 작동합니다.

---

Ubuntu와 RedHat에서 작동했습니다.

java -XX:+PrintFlagsFinal -version | grep -iE 'HeapSize|PermSize|ThreadStackSize'

Windows의 경우 :

java -XX:+PrintFlagsFinal -version | findstr /i "HeapSize PermSize ThreadStackSize"

Mac의 경우

java -XX:+PrintFlagsFinal -version | grep -iE 'heapsize|permsize|threadstacksize'

이 모든 명령의 출력은 아래 출력과 유사합니다.

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)

크기를 MB 단위로 찾으려면 값을 (1024 * 1024)로 나누십시오.

---

대부분의 도구가 사용하는 JMX를 사용하지 않고 사용하면됩니다.

jps -lvm

설정이 명령 행 옵션에서 오는 것으로 추론하십시오.

기본적으로 JMX가 없으면 동적 정보를 얻을 수 없지만이를 위해 고유 한 서비스를 작성할 수 있습니다.

BTW : JConsole 대신 VisualVM을 사용하는 것을 선호합니다.

---

시각적 측면 -jvm-mon 과 함께 명령 행 도구가 있습니다. 명령 행에 대한 JVM 모니터링 도구는 다음과 같습니다.

• 힙 사용량, 크기 및 최대
• jvm 프로세스
• CPU 및 GC 사용량
• 최고 실

도구가 열려있는 동안 메트릭과 차트가 업데이트됩니다.

견본:

---

늦었지만 파티는 매우 간단한 해결책은 jpsstat.sh 스크립트를 사용하는 것입니다. 그것은 간단한 라이브 전류 메모리 , 최대 메모리 및 CPU 사용 세부 정보를 제공합니다.

• 고토 GitHub의 프로젝트 와 다운로드 jpsstat.sh의 파일을
• Right click on jpsstat.sh and goto permissions tab and make it executable
• Now Run the script using following command ./jpsstat.sh

Here is the sample output of 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

---

Any approach should give you roughly same number. It is always a good idea to allocate the heap using -X..m -X..x for all generations. You can then guarantee and also do ps to see what parameters were passed and hence being used.

For actual memory usages, you can roughly compare VIRT (allocated and shared) and RES (actual used) compare against the jstat values as well:

For Java 8, see jstat for these values actually mean. Assuming you run a simple class with no mmap or file processing.

$ 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

(roughly close and below to VIRT memory)

Max(Min, Used):

215040 + 512 + 512 + 67072 + 430080  + 39680    +  4864  = ~ 1GB

(roughly close to RES memory)

"Don't quote me on this" but VIRT mem is roughly close to or more than Max memory allocated but as long as memory being used is free/available in physical memory, JVM does not throw memory exception. In fact, max memory is not even checked against physical memory on JVM startup even with swap off on OS. A better explanation of what Virtual memory really used by a Java process is discussed here.

---

From Java8 and above, you may use below command:

jcmd JAVA_PROCESS_ID GC.heap_info

You may refer to sum of, total and used memory from the output.

Sample Command And Output: jcmd 9758 GC.heap_info

PSYoungGen  total 1579520K, used 487543K [0x0000000751d80000, 0x00000007c0000000, 0x00000007c0000000)
  eden space 1354240K, 36% used [0x0000000751d80000,0x000000076f99dc40,0x00000007a4800000)
  from space 225280K, 0% used [0x00000007b2400000,0x00000007b2400000,0x00000007c0000000)
  to   space 225280K, 0% used [0x00000007a4800000,0x00000007a4800000,0x00000007b2400000)
ParOldGen       total 3610112K, used 0K [0x0000000675800000, 0x0000000751d80000, 0x0000000751d80000)
  object space 3610112K, 0% used [0x0000000675800000,0x0000000675800000,0x0000000751d80000)
Metaspace       used 16292K, capacity 16582K, committed 16896K, reserved 1064960K
  class space    used 1823K, capacity 1936K, committed 2048K, reserved 1048576K

For more details on jcmd command, visit link: https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html

---

First get the process id, the first number from the process listed, from one of the following: (or just use ps aux | grep java, if you prefer that)

jps -lvm

Then use the process ID here:

jmap -heap $MY_PID 2>/dev/null | sed -ne '/Heap Configuration/,$p';
jmap -permstat $MY_PID

---

If using jrockit try the jrcmd command line tool. For example:

$ 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)

For more commands, like heap_diagnostics, use "jrcmd help" to list them.

https://blogs.oracle.com/jrockit/entry/why_is_my_jvm_process_larger_t

---

Using top command is the simplest way to check memory usage of the program. RES column shows the real physical memory that is occupied by a process.

For my case, I had a 10g file read in java and each time I got outOfMemory exception. This happened when the value in the RES column reached to the value set in -Xmx option. Then by increasing the memory using -Xmx option everything went fine.

---

jstat -gccapacity javapid  (ex. stat -gccapacity 28745)
jstat -gccapacity javapid gaps frames (ex.  stat -gccapacity 28745 550 10 )

Sample O/P of above command

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).

Get more details about this at http://docs.oracle.com/javase/1.5.0/docs/tooldocs/share/jstat.html

---

In terms of Java heap size, in Linux, you can use

ps aux | grep java

or

ps -ef | grep java

and look for -Xms, -Xmx to find out the initial and maximum heap size specified.

However, if -Xms or -Xmx is absent for the Java process you are interested in, it means your Java process is using the default heap sizes. You can use the following command to find out the default sizes.

java -XX:+PrintFlagsFinal -version | grep HeapSize

or a particular jvm, for example,

/path/to/jdk1.8.0_102/bin/java -XX:+PrintFlagsFinal -version | grep HeapSize

and look for InitialHeapSize and MaxHeapSize, which is in bytes.

---

There is no such tool till now to print the heap memory in the format as you requested The Only and only way to print is to write a java program with the help of Runtime Class,

public class TestMemory {

public static void main(String [] args) {

    int MB = 1024*1024;

    //Getting the runtime reference from system
    Runtime runtime = Runtime.getRuntime();

    //Print used memory
    System.out.println("Used Memory:" 
        + (runtime.totalMemory() - runtime.freeMemory()) / MB);

    //Print free memory
    System.out.println("Free Memory:" 
        + runtime.freeMemory() / mb);

    //Print total available memory
    System.out.println("Total Memory:" + runtime.totalMemory() / MB);

    //Print Maximum available memory
    System.out.println("Max Memory:" + runtime.maxMemory() / MB);
}

}

reference:https://viralpatel.net/blogs/getting-jvm-heap-size-used-memory-total-memory-using-java-runtime/

---

In my case I needed to check the flags inside a docker container which didn't had most of the basic utilities (ps, pstree...)

Using jps I got the PID of the JVM running (in my case 1) and then with jcmd 1 VM.flags I got the flags from the running JVM.

It depends on what commands you have available, but this might help someone. :)

참고URL : https://stackoverflow.com/questions/12797560/command-line-tool-to-find-java-heap-size-and-memory-used-linux