jstack java堆栈跟踪工具

1、jstack介绍

jstack（stack trace for java）是java虚拟机自带的一种堆栈跟踪工具。

jstack主要用于生成java虚拟机当前时刻的线程快照，线程快照是当前java虚拟机内每一条线程正在执行的方法

堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源

导致的长时间等待等。

线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事

情，或者等待什么资源。

jstack主要分为两个功能：

1. 针对活着的进程做本地的或远程的线程dump
2. 针对core文件做线程dump

当指定的进程在64位Java虚拟机上运行时，可能需要指定-J-d64选项，例如：jstack -J-d64 -m pid。

2、线程状态

线程通常有下面5中状态：

1、新建状态（New）： 新创建了一个线程对象。

2、就绪状态（Runnable） ：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可

​ 运行线程池中，变得可运行，等待获取CPU的使用权。

3、运行状态（Running）： 就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态（Blocked）： 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就

​ 绪状态，才有机会转到运行状态。阻塞的情况分三种：

• 等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

• 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池

  中。

• 其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。

  当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

关于线程状态，具体也可以查看：java.lang.Thread.State类。

想要通过jstack命令来分析线程的情况的话，首先要知道线程都有哪些状态，下面这些状态是我们使用jstack命

令查看线程堆栈信息时可能会看到的线程的几种状态：

• RUNNABLE，线程运行中或I/O等待
• BLOCKED，线程被阻塞，在等待monitor锁(synchronized关键字)
• TIMED_WAITING ，线程在等待唤醒，但设置了时限
• WAITING ，线程在无限等待唤醒

在线程的堆栈中，需要特别留意以下几种状态：

• Deadlock： 死锁(重点关注)
• Waiting on condition： 等待资源(重点关注)
• Waiting on monitor entry ： 等待获取监视器(重点关注)
• Blocked ：阻塞(重点关注)
• Runnable ：执行中
• 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可执行程序。

core：要打印的堆栈跟踪的核心文件。

server-id：当多个DEBUG服务器在同一远程主机上运行时，可使用的可选唯一ID。

remote-hostname-or-IP：远程DEBUG的服务器主机名或IP地址。

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

常用参数说明：

-F：当 jstack [-l] pid 没有响应时，强制打印一个堆栈转储。

-l：打印关于锁的其他信息，比如拥有的java.util.concurrent ownable同步器的列表，会使得

JVM停顿得长久得多。

-m：打印包含Java和本机C/ C++帧的混合模式堆栈跟踪。

-h：打印帮助信息。

-help：打印帮助信息。

3.1 jstack pid

第一行各个单词的解析，

• daemon：线程名称 。

• prio：线程优先级

• tid：指Java Thread id。

• nid：指native线程的id。。

• [0x000000002369e000]：线程栈起始地址。

3.2 死循环

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。");
    }

}