腳本之家服務器常用軟件

快捷導航

java堆棧跟蹤工具jstack的使用教程

更新時間：2023年11月14日 08:41:25 作者：242030

jstack（stack?trace?for?java）是java虛擬機自帶的一種堆棧跟蹤工具,主要用于生成java虛擬機當前時刻的線程快照,下面我們就來學習一下它的具體使用吧

1、jstack介紹

jstack（stack trace for java）是java虛擬機自帶的一種堆棧跟蹤工具。

jstack主要用于生成java虛擬機當前時刻的線程快照，線程快照是當前java虛擬機內每一條線程正在執(zhí)行的方法堆棧的集合，生成線程快照的主要目的是定位線程出現(xiàn)長時間停頓的原因，如線程間死鎖、死循環(huán)、請求外部資源導致的長時間等待等。

線程出現(xiàn)停頓的時候通過jstack來查看各個線程的調用堆棧，就可以知道沒有響應的線程到底在后臺做什么事情，或者等待什么資源。

jstack主要分為兩個功能：

針對活著的進程做本地的或遠程的線程dump
針對core文件做線程dump

當指定的進程在64位Java虛擬機上運行時，可能需要指定-J-d64選項，例如：jstack -J-d64 -m pid。

2、線程狀態(tài)

線程通常有下面5中狀態(tài)：

1、新建狀態(tài)（New）：新創(chuàng)建了一個線程對象。

2、就緒狀態(tài)（Runnable）：線程對象創(chuàng)建后，其他線程調用了該對象的start()方法。該狀態(tài)的線程位于可運行線程池中，變得可運行，等待獲取CPU的使用權。

3、運行狀態(tài)（Running）：就緒狀態(tài)的線程獲取了CPU，執(zhí)行程序代碼。

4、阻塞狀態(tài)（Blocked）：阻塞狀態(tài)是線程因為某種原因放棄CPU使用權，暫時停止運行。直到線程進入就緒狀態(tài)，才有機會轉到運行狀態(tài)。阻塞的情況分三種：

等待阻塞：運行的線程執(zhí)行wait()方法，JVM會把該線程放入等待池中。

同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中。

其他阻塞：運行的線程執(zhí)行sleep()或join()方法，或者發(fā)出了I/O請求時，JVM會把該線程置為阻塞狀態(tài)。

當sleep()狀態(tài)超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態(tài)。

5、死亡狀態(tài)（Dead）：線程執(zhí)行完了或者因異常退出了run()方法，該線程結束生命周期。

關于線程狀態(tài)，具體也可以查看：java.lang.Thread.State類。

想要通過jstack命令來分析線程的情況的話，首先要知道線程都有哪些狀態(tài)，下面這些狀態(tài)是我們使用jstack命

令查看線程堆棧信息時可能會看到的線程的幾種狀態(tài)：

RUNNABLE，線程運行中或I/O等待
BLOCKED，線程被阻塞，在等待monitor鎖(synchronized關鍵字)
TIMED_WAITING ，線程在等待喚醒，但設置了時限
WAITING ，線程在無限等待喚醒

在線程的堆棧中，需要特別留意以下幾種狀態(tài)：

Deadlock：死鎖(重點關注)
Waiting on condition：等待資源(重點關注)
Waiting on monitor entry ：等待獲取監(jiān)視器(重點關注)
Blocked ：阻塞(重點關注)
Runnable ：執(zhí)行中
Suspended ：暫停
Object.wait()或TIME_WAITING ：對象等待中
Parked ：停止

3、jstack命令格式

jstack [ option ] pid
jstack [ option ] executable core
jstack [ option ] [server-id@]remote-hostname-or-IP

pid：Java進程的ID，可以通過jps命令查詢到。

executable：產生core dump的Java可執(zhí)行程序。

core：要打印的堆棧跟蹤的核心文件。

server-id：當多個DEBUG服務器在同一遠程主機上運行時，可使用的可選唯一ID。

remote-hostname-or-IP：遠程DEBUG的服務器主機名或IP地址。

pid：需要被打印配置信息的java進程id，可以用jps查詢。

常用參數(shù)說明：

-F：當 jstack [-l] pid 沒有響應時，強制打印一個堆棧轉儲。

-l：打印關于鎖的其他信息，比如擁有的java.util.concurrent ownable同步器的列表，會使得JVM停頓得長久得多。

-m：打印包含Java和本機C/ C++幀的混合模式堆棧跟蹤。

-h：打印幫助信息。

-help：打印幫助信息。

3.1 jstack pid

第一行各個單詞的解析，

daemon：線程名稱。

prio：線程優(yōu)先級

tid：指Java Thread id。

nid：指native線程的id。。

[0x000000002369e000]：線程棧起始地址。

3.2 死循環(huán)

package com.example.controller;

public class Test2 {

    public static void main(String[] args) {
        while (true) {
        }
    }
    
}

3.3 Object.wait()情況

package com.example.controller;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test3 {
    static class TestTask implements Runnable {
        @Override
        public void run() {
            synchronized (this) {
                try {
                    //等待被喚醒
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService ex = Executors.newFixedThreadPool(1);
        ex.execute(new TestTask());
    }
}

3.4 死鎖情況

package com.example.controller;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test4 {

    public static void main(String[] args) {
        Object obj1 = new Object();
        Object obj2 = new Object();
        ExecutorService ex = Executors.newFixedThreadPool(2);
        // 起10個線程
        for (int i = 0; i < 10; i++) {
            int order = i % 2 == 0 ? 1 : 0;
            ex.execute(new TestTask(order, obj1, obj2));
        }
    }

    static class TestTask implements Runnable {
        private Object obj1;
        private Object obj2;
        private int order;

        public TestTask(int order, Object obj1, Object obj2) {
            this.order = order;
            this.obj1 = obj1;
            this.obj2 = obj2;
        }

        public void test1() throws InterruptedException {
            synchronized (obj1) {
                synchronized (obj2) {
                    System.out.println("test。。。");
                }
            }
        }

        public void test2() throws InterruptedException {
            synchronized (obj2) {
                synchronized (obj1) {
                    System.out.println("test。。。");
                }
            }
        }

        @Override
        public void run() {
            while (true) {
                try {
                    if (this.order == 1) {
                        this.test1();
                    } else {
                        this.test2();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.5 等待io

package com.example.controller;

import java.io.IOException;
import java.io.InputStream;

public class Test5 {

    public static void main(String[] args) throws IOException {
        InputStream is = System.in;
        int i = is.read();
        System.out.println("exit。");
    }

}