JVM 監控，調優，調試 JVM系列三:JVM參數設置、分析

JVM監控工具

Java的安裝包自帶了不少優秀的工具，善用這些工具對於監控和調試Java程序很是有幫助。經常使用工具以下：

jps 

---

用途：jps用來查看JVM裏面全部進程的具體狀態, 包括進程ID，進程啓動的路徑等等。

經常使用參數：

-l: 輸出完成的包名稱；

-m: 輸出程序的命令行輸入參數；

-v: 輸出完整的JVM參數。

jstack 

---

用途：1）查看java程序崩潰生成core文件，得到core文件的java stack和native stack的信息；

          2）查看正在運行的java程序的java stack和native stack的信息：a) 查看運行的java程序呈現hung的狀態；b) 跟蹤Java的調用棧，剖析程序。

jinfo

---

用途：jinfo可觀察運行中的java程序的運行環境參數：參數包括Java System屬性和JVM命令行參數；也可從core文件裏面知道崩潰的Java應用程序的配置信息。

jstat

---

用途：jstat利用了JVM內建的指令對Java應用程序的資源和性能進行實時的命令行的監控，包括了對Heap size和垃圾回收情況的監控等等。

語法結構：

Usage: jstat -help|-options

       jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]

參數解釋：

Options — 選項，咱們通常使用 -gcutil 查看gc狀況

vmid    — VM的進程號，即當前運行的java進程號

interval– 間隔時間，單位爲秒或者毫秒

count   — 打印次數，若是缺省則打印無數次

具體option參數以下：

-class：統計class loader行爲信息

-compile：統計編譯行爲信息

-gc：統計jdk gc時heap信息

-gccapacity：統計不一樣的generations（不知道怎麼翻譯好，包括新生區，老年區，permanent區）相應的heap容量狀況

-gccause：統計gc的狀況，（同-gcutil）和引發gc的事件

-gcnew：統計gc時，新生代的狀況

-gcnewcapacity：統計gc時，新生代heap容量

-gcold：統計gc時，老年區的狀況

-gcoldcapacity：統計gc時，老年區heap容量

-gcpermcapacity：統計gc時，permanent區heap容量

-gcutil：統計gc時，heap狀況

輸出內容含義以下：

S0  — Heap上的 Survivor space 0 區已使用空間的百分比

S1  — Heap上的 Survivor space 1 區已使用空間的百分比

E   — Heap上的 Eden space 區已使用空間的百分比

O   — Heap上的 Old space 區已使用空間的百分比

P   — Perm space 區已使用空間的百分比

YGC — 從應用程序啓動到採樣時發生 Young GC 的次數

YGCT– 從應用程序啓動到採樣時 Young GC 所用的時間(單位秒)

FGC — 從應用程序啓動到採樣時發生 Full GC 的次數

FGCT– 從應用程序啓動到採樣時 Full GC 所用的時間(單位秒)

GCT — 從應用程序啓動到採樣時用於垃圾回收的總時間(單位秒) 

示例

實例使用1：

[root@localhost bin]# jstat -gcutil 25444

  S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT

 11.63   0.00   56.46  66.92  98.49 162    0.248    6      0.331    0.579 

實例使用2：

[root@localhost bin]# jstat -gcutil 25444 1000 5

  S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT

 73.54   0.00  99.04  67.52  98.49    166    0.252     6    0.331    0.583

 73.54   0.00  99.04  67.52  98.49    166    0.252     6    0.331    0.583

 73.54   0.00  99.04  67.52  98.49    166    0.252     6    0.331    0.583

 73.54   0.00  99.04  67.52  98.49    166    0.252     6    0.331    0.583

 73.54   0.00  99.04  67.52  98.49    166    0.252     6    0.331    0.583 

咱們能夠看到，5次young gc以後，垃圾內存被從Eden space區(E)放入了Old space區(O)，並引發了百分比的變化，致使Survivor space使用的百分比從73.54%(S0)降到0%(S1)。有效釋放了內存空間。綠框中，咱們能夠看到，一次full gc以後，Old space區(O)的內存被回收，從99.05%降到67.52%。

圖中同時打印了young gc和full gc的總次數、總耗時。而，每次young gc消耗的時間，能夠用相間隔的兩行YGCT相減獲得。每次full gc消耗的時間，能夠用相隔的兩行FGCT相減獲得。例如紅框中表示的第一行、第二行之間發生了1次young gc，消耗的時間爲0.252-0.252＝0.0秒。

常駐內存區(P)的使用率，始終停留在98.49%左右，說明常駐內存沒有突變，比較正常。

若是young gc和full gc可以正常發生，並且都能有效回收內存，常駐內存區變化不明顯，則說明java內存釋放狀況正常，垃圾回收及時，java內存泄露的概率就會大大下降。但也不能說明必定沒有內存泄露。

GCT 是YGCT 和FGCT的時間總和。

以上，介紹了Jstat按百分比查看gc狀況的功能。其實，它還有功能，例如加載類信息統計功能、內存池信息統計功能等，那些是以絕對值的形式打印出來的，比較少用，在此就不作介紹。 

[root@localhost bin]# ps -ef | grep java

root     25917     1  2 23:23 pts/2    00:00:05 /usr/local/jdk1.5/bin/java -Djava.endorsed.dirs=/usr/local/jakarta-tomcat-5.0.30/common/endorsed -classpath /usr/local/jdk1.5/lib/tools.jar:/usr/local/jakarta-tomcat-5.0.30/bin/bootstrap.jar:/usr/local/jakarta-tomcat-5.0.30/bin/commons-logging-api.jar -Dcatalina.base=/usr/local/jakarta-tomcat-5.0.30 -Dcatalina.home=/usr/local/jakarta-tomcat-5.0.30 -Djava.io.tmpdir=/usr/local/jakarta-tomcat-5.0.30/temp org.apache.catalina.startup.Bootstrap start

jstat -class pid:顯示加載class的數量，及所佔空間等信息。

實例使用3：

[root@localhost bin]# jstat -class 25917

Loaded  Bytes  Unloaded  Bytes     Time

2629    2916.8       29   24.6     0.90 

jstat -compiler pid:顯示VM實時編譯的數量等信息。

實例使用4：

[root@localhost bin]# jstat -compiler 25917

Compiled Failed Invalid   Time   FailedType FailedMethod

     768      0       0   0.70            0 

jstat –gccapacity :能夠顯示，VM內存中三代（young,old,perm）對象的使用和佔用大小，如：PGCMN顯示的是最小perm的內存使用量，PGCMX顯示的是perm的內存最大使用量，PGC是當前新生成的perm內存佔用量，PC是但前perm內存佔用量。其餘的能夠根據這個類推， OC是old內純的佔用量。 

[root@localhost bin]# jstat -gccapacity 25917

NGCMN       640.0

NGCMX       4992.0

NGC         832.0

S0C         64.0

S1C         64.0

EC          704.0

OGCMN       1408.0

OGCMX       60544.0

OGC         9504.0

OC          9504.0                  OC是old內純的佔用量

PGCMN       8192.0                  PGCMN顯示的是最小perm的內存使用量

PGCMX       65536.0                 PGCMX顯示的是perm的內存最大使用量

PGC         12800.0                 PGC是當前新生成的perm內存佔用量

PC          12800.0                 PC是但前perm內存佔用量

YGC         164

FGC         6 

jstat -gcnew pid: new對象的信息

[root@localhost bin]# jstat -gcnew 25917

 S0C    S1C    S0U    S1U   TT MTT  DSS      EC       EU     YGC     YGCT

 64.0   64.0   47.4   0.0   2  15   32.0    704.0    145.7    168    0.254 

jstat -gcnewcapacity pid: new對象的信息及其佔用量

[root@localhost bin]# jstat -gcnewcapacity 25917

 NGCMN  NGCMX   NGC   S0CMX  S0C   S1CMX  S1C   ECMX    EC      YGC   FGC

640.0  4992.0  832.0 64.0   448.0 448.0  64.0   4096.0  704.0  168     6

jstat -gcold pid: old對象的信息。

[root@localhost bin]# jstat -gcold 25917

   PC       PU        OC          OU       YGC    FGC    FGCT     GCT

 12800.0  12617.6     9504.0      6561.3   169     6    0.335    0.591

jstat -gcoldcapacity pid:old對象的信息及其佔用量。

[root@localhost bin]# jstat -gcoldcapacity 25917

OGCMN      OGCMX        OGC         OC       YGC   FGC    FGCT     GCT

1408.0     60544.0      9504.0      9504.0   169     6    0.335    0.591 

jstat -gcpermcapacity pid: perm對象的信息及其佔用量。

[root@localhost bin]# jstat -gcpermcapacity 25917

PGCMN      PGCMX       PGC         PC      YGC   FGC    FGCT     GCT

8192.0    65536.0    12800.0    12800.0   169     6    0.335    0.591 

jstat -printcompilation pid:當前VM執行的信息。

[root@localhost bin]# jstat -printcompilation -h3  25917 1000 5

每1000毫秒打印一次，一共打印5次，還能夠加上-h3每三行顯示一下標題。

Compiled  Size  Type Method

     788     73    1 java/io/File <init>

     788     73    1 java/io/File <init>

     788     73    1 java/io/File <init>

Compiled  Size  Type Method

     788     73    1 java/io/File <init>

     788     73    1 java/io/File <init>

jmap

---

用途：觀察運行中的jvm物理內存的佔用狀況，包括Heap size, Perm size等等。

參數以下：

-heap：打印jvm heap的狀況

-histo：打印jvm heap的直方圖。其輸出信息包括類名，對象數量，對象佔用大小。

-histo：live ：同上，可是隻答應存活對象的狀況

-permstat：打印permanent generation heap狀況

命令使用：

jmap -heap 2083 ---- 觀察到New Generation（Eden Space，From Space，To Space）,tenured generation,Perm Generation的內存使用狀況

jmap -histo 2083 ｜ jmap -histo:live 2083   ---- 觀察heap中全部對象的狀況（heap中全部生存的對象的狀況）。包括對象數量和所佔空間大小。

jmap -dump:live,format=b,file=heap.bin 2083 ---- dump java heap in hprof binary format。輸出文件可用於進一步分析。

class name對應的就是Class文件裏的class的標識
B表明byte
C表明char
D表明double
F表明float
I表明int
J表明long
Z表明boolean
前邊有[表明數組，[I 就至關於int[]
對象用[L+類名錶示

 

 

BaseType Character	Type	Interpretation
B	byte	signed byte
C	char	Unicode character
D	double	double-precision floating-point value
F	float	single-precision floating-point value
I	int	integer
J	long	long integer
L<classname>;	reference	an instance of class de><classname>de>
S	short	signed short
Z	boolean	de>truede> or de>falsede>
[	reference	one array dimension

 

Java調優

---

 

                JVM調優總結 

                JAVA虛擬機性能參數調優指導書

                Jprofiler使用介紹

                Memory Analyzer (MAT)

                使用Memory Analyzer tool(MAT)分析內存泄漏

JVM常見參數及其默認值：

（詳見：JVM系列三:JVM參數設置、分析）

參數名稱	含義	默認值
-Xms	初始堆大小	物理內存的1/64(<1GB)	默認(MinHeapFreeRatio參數能夠調整)空餘堆內存小於40%時，JVM就會增大堆直到-Xmx的最大限制.
-Xmx	最大堆大小	物理內存的1/4(<1GB)	默認(MaxHeapFreeRatio參數能夠調整)空餘堆內存大於70%時，JVM會減小堆直到 -Xms的最小限制
-Xmn	年輕代大小(1.4or lator)		注意：此處的大小是（eden+ 2 survivor space).與jmap -heap中顯示的New gen是不一樣的。 整個堆大小=年輕代大小 + 年老代大小 + 持久代大小. 增大年輕代後,將會減少年老代大小.此值對系統性能影響較大,Sun官方推薦配置爲整個堆的3/8
-XX:NewSize	設置年輕代大小(for 1.3/1.4)
-XX:MaxNewSize	年輕代最大值(for 1.3/1.4)
-XX:PermSize	設置持久代(perm gen)初始值	物理內存的1/64
-XX:MaxPermSize	設置持久代最大值	物理內存的1/4
-Xss	每一個線程的堆棧大小		JDK5.0之後每一個線程堆棧大小爲1M,之前每一個線程堆棧大小爲256K.更具應用的線程所需內存大小進行 調整.在相同物理內存下,減少這個值能生成更多的線程.可是操做系統對一個進程內的線程數仍是有限制的,不能無限生成,經驗值在3000~5000左右 通常小的應用， 若是棧不是很深， 應該是128k夠用的 大的應用建議使用256k。這個選項對性能影響比較大，須要嚴格的測試。（校長） 和threadstacksize選項解釋很相似,官方文檔彷佛沒有解釋,在論壇中有這樣一句話:"」 -Xss is translated in a VM flag named ThreadStackSize」 通常設置這個值就能夠了。

 

JVM配置示例：

JAVA_OPTS="-server -XX:+UseConcMarkSweepGC -XX:PermSize=100M  -XX:MaxPermSize=300M -Xms8g -Xmx8g -Xmn4g -Xss256k -XX:MaxNewSize=4g -XX:NewSize=4g -XX:SurvivorRatio=2  -Xnoclassgc -XX:+DisableExplicitGC  -XX:+UseParNewGC -XX:ParallelGCThreads=8 -XX:+CMSParallelRemarkEnabled -XX:+UseCMSCompactAtFullCollection -XX:CMSFullGCsBeforeCompaction=0 -XX:+CMSClassUnloadingEnabled -XX:CMSInitiatingOccupancyFraction=92 -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+UseCMSInitiatingOccupancyOnly -XX:+PrintHeapAtGC -Xloggc:/data/resys/zhenjing/tomcat-solr-slave/logs/gc.log -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime -Duser.timezone=Asia/Shanghai -XX:MaxDirectMemorySize=7g -Dcom.tc.productkey.path=/data/conf/terracotta-license.key"

機器配置：4CPU，16G內存

-server -Xms8g -Xmx8g -XX:PermSize=256m -XX:MaxPermSize=256m -Xmn4g -XX:MaxDirectMemorySize=512m -XX:SurvivorRatio=8 -XX:+UseConcMarkSweepGC -XX:+UseCMSCompactAtFullCollection -XX:CMSMaxAbortablePrecleanTime=5000 -XX:+CMSClassUnloadingEnabled -XX:CMSInitiatingOccupancyFraction=80 -XX:+UseCMSInitiatingOccupancyOnly -XX:+ExplicitGCInvokesConcurrent -Dsun.rmi.dgc.server.gcInterval=2592000000 -Dsun.rmi.dgc.client.gcInterval=2592000000 -XX:ParallelGCThreads=4 -Xloggc:/data/logs/gc.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/data/logs/java.hprof -Djava.awt.headless=true -Dsun.net.client.defaultConnectTimeout=10000 -Dsun.net.client.defaultReadTimeout=30000 -Dfile.encoding=UTF-8 -Ddubbo.application.logger=slf4j -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=8082 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.rmi.server.hostname=10.2.113.82

說明：

# 各個堆棧區域空間分配
-server 
-XX:PermSize=100M  
-XX:MaxPermSize=300M 
-Xms8g -Xmx8g -Xmn4g -Xss256k 
-XX:MaxNewSize=4g -XX:NewSize=4g 
-XX:SurvivorRatio=2       # eden = from+to

# 回收算法相關。該配置以知足響應實時性爲目的。
-Xnoclassgc    #禁用類垃圾回收，性能會高一點； 
-XX:+DisableExplicitGC   #禁止System.gc()
-XX:+UseConcMarkSweepGC    #老年代回收採用CMS算法
-XX:+UseParNewGC                #年輕代回收採用並行算法
-XX:ParallelGCThreads=8 
-XX:+CMSParallelRemarkEnabled 
-XX:+UseCMSCompactAtFullCollection 
-XX:CMSFullGCsBeforeCompaction=0 
-XX:+CMSClassUnloadingEnabled 
-XX:CMSInitiatingOccupancyFraction=92 
-XX:SoftRefLRUPolicyMSPerMB=0 

# gc日誌相關。 採用 jstat -gcutil PID 10000 監控更簡潔直觀。
-XX:+PrintGCDetails 
-XX:+PrintGCTimeStamps 
-XX:+UseCMSInitiatingOccupancyOnly 
-XX:+PrintHeapAtGC 
-Xloggc:logs/gc.log 
-XX:+PrintGCApplicationConcurrentTime 
-XX:+PrintGCApplicationStoppedTime 
-Duser.timezone=Asia/Shanghai 

# BigMemory for Ehcache 相關配置，啓用本地緩存，避免觸發gc。
-XX:MaxDirectMemorySize=7g 
-Dcom.tc.productkey.path=/data/conf/terracotta-license.key

幾點說明：

Young GC: 通常狀況下，當生成新對象，觸發Eden申請空間失敗時，就會觸發Scavenge GC，對Eden區域進行GC，清除非存活對象，而且把尚且存活的對象移動到空的Survivor區(to Survivor)。而後整理上次存放數據的Survivor(from Survivor)，將依然存活的對象放入新的to Survivor。若屢次整理後，對象依然存活，且達到閾值(由 InitialTenuringThreshold 和 MaxTenuringThreshold 控制，默認值爲7和15)，則將對象放入老年代。

Full GC: 主要是回收老年代的失效對象，通常同時觸發整理年輕代。

幾個參考數據：gc的核心工做是：清除無效對象；移動有效對象。若須要清除的無效對象不少，或須要移動的有效對象不少，則gc過程耗時。對於4G的年輕代，2G的eden代，一次Young GC大概耗時100~200ms。 若實際應用中，Young GC超過200ms，通常須要調優JVM。調優的目標：1）下降單次Young GC時間； 2) 下降Full GC次數。  Young GC 的次數和程序的負載和對象使用方式(代碼實現方式)有關，優化空間不大。

測試過 -XX:+AggressiveHeap 選項，對gc影響不大。測試過 -XX:+UseFastAccessorMethods -XX:+AggressiveOpts -XX:+UseBiasedLocking 選項，對gc影響不大。 

對於-XX:LargePageSizeInBytes=128m選項，有些麻煩，且可能致使Full GC變長，沒試用。參見：http://hllvm.group.iteye.com/group/wiki/2870-JVM

Java調試輔助工具

---

 

連接的jar庫可能包含重複的class，致使行爲錯誤。

findclass.sh 用於查找特定類名出如今哪些jar包。

#! /bin/bash

if [ $# -lt 2 ]; then
    echo "Usage: $0 classname jar1 jar2..."
    exit -1
fi

classname=$1
echo "Find Class: $classname"
shift

for file in $*
do
    # echo $file
    suffix=${file##*.}
    if [ "x$suffix" == "xjar" ]; then
            
            grepret=`jar -tf $file | grep $classname`
            # echo $grepret
            if [ "x$grepret" != "x" ]; then
                echo "$file"
            fi
    fi

done

jps_kill.sh 用於kill指定類名的的java進程。JVM很耗資源，當啓動的JVM達到幾百個時，系統負載很重，會致使jps運行變慢(一、負載重；二、進程多)。

#! /bin/bash

TMP=/tmp/jps_kill.log

if [ $# -lt 1 ]
then
    echo "Usage: $0 prog_name"
    exit -1
fi

jps | grep -i $1 > $TMP

while read pid other
do
    echo $pid
    #echo $other

    kill -9 $pid

done < $TMP

gcstat.sh 長期監控JVM的gc情況。

#!/bin/bash

PID=-1
INTERVAL=1000
NUM=60000000

if [[ $# -lt 1 ]]
then
    echo "Usage: $0 <vmid> [<interval(ms)> [<count>]]"
    exit 1
fi
PID=$1

if [[ $# -gt 1 ]]
then
        INTERVAL=$2
fi

if [[ $# -gt 2 ]]
then
        NUM=$3
fi

echo "$0 Start test...`date`"
echo 
    
    jstat  -gcutil -t -h50 $PID  $INTERVAL  $NUM

echo "$0 Finish test.`date`"

jmap_stat.sh 長期監控jmap情況。

#!/bin/bash

PID=-1
INTERVAL=3
NUM=60

if [[ $# -lt 1 ]]
then
    echo "Usage: $0 <vmid> [<interval> [<count>]]"
    exit 1
fi
PID=$1

if [[ $# -gt 1 ]]
then
        INTERVAL=$2
fi

if [[ $# -gt 2 ]]
then
        NUM=$3
fi

echo "$0 Start test...`date`"
echo 


i=0
while [[ i -lt $NUM ]]
do
    echo `date`
    jmap -histo:live  $PID  | head -n 20    

    echo 
    sleep $INTERVAL

    ((i++))
done

echo "$0 Finish test.`date`"

Java調試輔助函數

---

 

調試Java程序常常須要知道Java進程PID、當前目錄、Java Home、內存使用狀況、執行特定命令等等。JavaDebug收集了上述這些經常使用的輔助調試函數。

import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;

import java.io.File;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;

public class JavaDebug{

    public static int getPid() {
        RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
        String name = runtime.getName(); // format: "pid@hostname"
        try {
            return Integer.parseInt(name.substring(0, name.indexOf('@')));
        } catch (Exception e) {
            System.err.println(e.getMessage());
            return -1;
        }
    }

    public static void printEnv(){
        Map<String,String> map = System.getenv();
        Iterator<Map.Entry<String, String>> iter = map.entrySet().iterator();
        Map.Entry<String, String> entry;
        while (iter.hasNext()) {
            entry = iter.next();
            String name = entry.getKey();
            String value = entry.getValue();

            System.out.println(name + ": "+ value);
        }
    }

    public static void printProperties(){
        Properties pros = System.getProperties();
        pros.list(System.out);
    }

    public static String getPWD(){
        return System.getProperty("user.dir");
    }

    public static void printSimpleMemoryInfo(){
        Runtime runTime = Runtime.getRuntime();
        System.out.println("Total Mem:" + runTime.totalMemory() + " Max Mem:" +runTime.maxMemory()
                + " Free mem:" + runTime.freeMemory() );
    }

    public static void printMemoryInfo(String info){
        if( info != null){
            System.out.println(info+ " JavaDebug:printMemoryInfo");
        }

        printSimpleMemoryInfo();
        ExecCommand("jmap " + getPid());
    }

    public static void ExecCommand(String cmd){
        System.out.println("Exec command: "+cmd);

        try{
            Process pro = null;
            Runtime runTime = Runtime.getRuntime();
            if (runTime == null) {
                System.err.println("Create runtime false!");
                throw new RuntimeException("Create runtime false!");
            }

            pro = runTime.exec(cmd);
            BufferedReader input = new BufferedReader(new InputStreamReader(pro.getInputStream()));
            PrintWriter output = new PrintWriter(new OutputStreamWriter(pro.getOutputStream()));
            String line;
            while ((line = input.readLine()) != null) {
                System.out.println(line);
            }
            input.close();
            output.close();
            pro.destroy();
        }
        catch(IOException e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
            throw new RuntimeException("run command error!");
        }

        System.out.println("Exec command: "+cmd + " finish.");
    }


    public static void main(String[] args) throws Exception {
        printProperties();

        //printEnv();

        System.out.println("========================");
        int pid = getPid();
        System.out.println("pid: " + pid);
        System.out.println("pwd: " + getPWD());

        printMemoryInfo(null);

        ExecCommand("ls -l");
        ExecCommand("jmap " + pid);

        printMemoryInfo(null);
    }
}