jstack-分析线程

最新推荐文章于 2024-04-30 16:40:35 发布

原创最新推荐文章于 2024-04-30 16:40:35 发布 · 1.2k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#jstack #多线程

jvm 专栏收录该内容

10 篇文章

订阅专栏

jstack是一款强大的Java虚拟机堆栈跟踪工具，用于打印Java进程的线程快照，帮助诊断线程问题如死锁。线程状态包括RUNNABLE、BLOCKED、WAITING和TIMED_WAITING等。在分析时，先通过JPS获取进程ID，然后使用jstack pid获取详细信息。此工具在排查多线程应用的性能问题时非常有用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1 概述

jstack是java虚拟机自带的一种堆栈跟踪工具。jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息

stack用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等。

jstack命令主要用来查看Java线程的调用堆栈的，可以用来分析线程问题（如死锁）。

2 使用

如果是在64位机器上，需要指定选项"-J-d64"，Windows的jstack使用方式只支持以下的这种方式：

jstack [-l] pid

3 线程状态

想要通过jstack命令来分析线程的情况的话，首先要知道线程都有哪些状态，下面这些状态是我们使用jstack命令查看线程堆栈信息时可能会看到的线程的几种状态：

NEW:未启动的。不会出现在Dump中。

RUNNABLE:在虚拟机内执行的。运行中状态，可能里面还能看到locked字样，表明它获得了某把锁。

BLOCKED:受阻塞并等待监视器锁。被某个锁(synchronizers)給block住了。

WATING:无限期等待另一个线程执行特定操作。等待某个condition或monitor发生，一般停留在park(), wait(), sleep(),join() 等语句里。

TIMED_WATING:有时限的等待另一个线程的特定操作。和WAITING的区别是wait() 等语句加上了时间限制 wait(timeout)。

TERMINATED,已退出的。

4 JPS 查看进程pid

5 举例说明

public class App 
{
/**
     * jps 获取进程pid
     * jstack pid 查看线程运行状态
     * @param args
     */
    public static void main( String[] args )
    {
Runnable();
    }


/**
     *
     * 处在运行状态的线程
     */
    public static void Runnable(){
        System.out.println( "测试jstack" );
        Thread th=new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){

                }
            }
        });
        th.setName("测试jstack");
        th.start();
        try {
//等待线程执行完毕
            th.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

/**
 * 处在等待状态的线程
 */
public static void Waiting(){
    System.out.println( "测试jstack" );
    Thread th=new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (this) {
                try {
                    //获取锁才能wait
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    th.setName("测试jstack");
    th.start();
    try {
//等待线程执行完毕
        th.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

/**
 *
 * 处在睡眠状态的线程
 */
public static void sleep(){
    System.out.println( "测试jstack" );
    Thread th=new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(600000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    th.setName("测试jstack");
    th.start();
    try {
//等待线程执行完毕
        th.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

/**

 * 处在死锁状态的线程
 */
public static void deadlock(){
    System.out.println( "测试jstack" );
    final Object lockA=new Object();
    final Object lockB=new Object();
    Thread thA=new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (lockA) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockB){

               }
            }
        }
    });
    thA.setName("测试jstack-A");
    thA.start();

    Thread thB=new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (lockB) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockA){

                }
            }
        }
    });
    thB.setName("测试jstack-B");
    thB.start();
    try {
//等待线程执行完毕
        thA.join();
        thB.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}