精华内容
下载资源
问答
  • 抓取jstack方法及解决system用户执行jstack命令权限问题, 打开cmd窗口,输入命令 jstack -l 49824>>C:/error01.txt 其中49824为tomcat8.0 的pid ; error01.txt 这个可以自己取名字 多输出几份jstack 文件,做比对...
  • 主要介绍了如何通过jstack命令dump线程信息,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Linux jstack命令详解

    2021-05-09 04:30:09
    如果是在64位机器上,需要指定选项"-J-d64",Windows的jstack使用方式只支持以下的这种方式:jstack[-l]pid如果java程序崩溃生成core文件,jstack工具可以用来获得core文件的javastack和nativestack的信息,从而可以...

    jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息。

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

    如果java程序崩溃生成core文件,jstack工具可以用来获得core文件的java stack和native stack的信息,从而可以轻松地知道java程序是如何崩溃和在程序何处发生问题。

    另外,jstack工具还可以附属到正在运行的java程序中,看到当时运行的java程序的java stack和native stack的信息, 如果现在运行的java程序呈现hung的状态,jstack是非常有用的。

    需要注意的问题:

    l 不同的 JAVA虚机的线程 DUMP的创建方法和文件格式是不一样的,不同的 JVM版本, dump信息也有差别。

    l 在实际运行中,往往一次 dump的信息,还不足以确认问题。建议产生三次 dump信息,如果每次 dump都指向同一个问题,我们才确定问题的典型性。

    2、命令格式

    $jstack [ option ] pid

    $jstack [ option ] executable core

    $jstack [ option ] [server-id@]remote-hostname-or-IP

    参数说明:

    pid: java应用程序的进程号,一般可以通过jps来获得;

    executable:产生core dump的java可执行程序;

    core:打印出的core文件;

    remote-hostname-or-ip:远程debug服务器的名称或IP;

    server-id: 唯一id,假如一台主机上多个远程debug服务;

    示例:

    $jstack –l 23561

    线程分析:

    一般情况下,通过jstack输出的线程信息主要包括:jvm自身线程、用户线程等。其中jvm线程会在jvm启动时就会存在。对于用户线程则是在用户访问时才会生成。

    l jvm线程:

    在线程中,有一些 JVM内部的后台线程,来执行譬如垃圾回收,或者低内存的检测等等任务,这些线程往往在JVM初始化的时候就存在,如下所示:

    "Attach Listener" daemon prio=10 tid=0x0000000052fb8000 nid=0xb8f waiting on condition [0x0000000000000000]

    java.lang.Thread.State: RUNNABLE

    Locked ownable synchronizers:

    - None

    destroyJavaVM" prio=10 tid=0x00002aaac1225800 nid=0x7208 waiting on condition [0x0000000000000000]

    java.lang.Thread.State: RUNNABLE

    Locked ownable synchronizers:

    - None

    l 用户级别的线程

    还有一类线程是用户级别的,它会根据用户请求的不同而发生变化。该类线程的运行情况往往是我们所关注的重点。而且这一部分也是最容易产生死锁的地方。

    "qtp496432309-42" prio=10 tid=0x00002aaaba2a1800 nid=0x7580 waiting on condition [0x00000000425e9000]

    java.lang.Thread.State: TIMED_WAITING (parking)

    at sun.misc.Unsafe.park(Native Method)

    - parking to wait for <0x0000000788cfb020> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)

    at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:198)

    at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2025)

    at org.eclipse.jetty.util.BlockingArrayQueue.poll(BlockingArrayQueue.java:320)

    at org.eclipse.jetty.util.thread.QueuedThreadPool$2.run(QueuedThreadPool.java:479)

    at java.lang.Thread.run(Thread.java:662)

    Locked ownable synchronizers:

    - None

    从上述的代码示例中我们可以看到该用户线程的以下几类信息:

    Ø 线程的状态:waiting on condition(等待条件发生)

    Ø 线程的调用情况;

    Ø 线程对资源的锁定情况;

    linux awk命令详解

    linux awk命令详解 简介 awk是一个强大的文本分析工具,相对于grep的查找,sed的编辑,awk在其对数据分析并生成报告时,显得尤为强大.简单来说awk就是把文件逐行的读入,以空格为默认分 ...

    linux cat 命令详解

    linux cat 命令详解 http://linux.chinaunix.net/techdoc/system/2007/11/16/972467.shtml adb shell su //这个不一 ...

    【初级】linux rm 命令详解及使用方法实战

    rm:删除命令 前言: windows中的删除命令大家都不陌生,linux中的删除命令和windows中有一个共同特点,那就是危险,前两篇linux mkdir 命令详解及使用方法实战[初级]中我们就 ...

    Linux netstat命令详解

    Linux netstat命令详解 一  简介 Netstat 命令用于显示各种网络相关信息,如网络连接,路由表,接口状态 (Interface Statistics),masquerade 连接,多 ...

    linux grep命令详解

    linux grep命令详解 简介 grep (global search regular expression(RE) and print out the line,全面搜索正则表达式并把行打印出来 ...

    Linux chmod命令详解

    Linux chmod命令详解 chmod----改变一个或多个文件的存取模式(mode)   chmod [options] mode files   只能文件属主或特权用户才能使用该功能来改变文件 ...

    【转发】linux yum命令详解

    linux yum命令详解 yum(全 称为 Yellow dog Updater, Modified)是一个在Fedora和RedHat以及SUSE中的Shell前端软件包管理器.基於RPM包管理, ...

    linux iostat命令详解 磁盘操作监控工具

    Linux系统中的 iostat是I/O statistics(输入/输出统计)的缩写,iostat工具将对系统的磁盘操作活动进行监视. 它的特点是汇报磁盘活动统计情况,同时也会汇报出CPU使用情况. ...

    linux yum 命令 详解

    linux yum命令详解 yum(全称为 Yellow dog Updater, Modified)是一个在Fedora和RedHat以及SUSE中的Shell前端软件包管理器.基於RPM包管理,能 ...

    随机推荐

    分布式唯一ID生成服务

    SNService是一款基于分布式的唯一ID生成服务,主要用于提供大数量业务数据建立唯一ID的需要;服务提供最低10K/s的唯一ID请求处理.如果你部署服务的CPU资源达到4核的情况下那该服务最低可以 ...

    java 文件操作

    1.按行读取 File file = new File(“your path”); BufferedReader reader = null; try { //System.out.println(& ...

    HTML 空格的表示符号 nbsp &sol; ensp &sol; emsp 的区别?

    半角的不断行的空白格(推荐使用)   半角的空格   全角的空格   半角的不断行的空白格(推荐使用)    半角的空格     全角的空格

    关于CodeReview(java)(转)

    关于codereview,在平时的开发中,经常忽略的环节,参照目前介绍写好代码的几本书和之前掉进的坑,做了一个总结,分享出来. 为什么要做 通过review规避一些代码层面的问题 提升可读性,方便后续 ...

    require&period;js实践

    ASP.NET MVC应用require.js实践 这里有更好的阅读体验和及时的更新:http://pchou.info/javascript/asp.net/2013/11/10/527f6ec41 ...

    R语言包下载(转载)

    http://blog.csdn.net/hongjinlongno1/article/details/53130893 包含几乎所有包,很方便

    linux eaccelerator

    wget https://github.com/eaccelerator/eaccelerator/tarball/master tar -jxvf eaccelerator-0.9.6.1.tar. ...

    SaltStack一键部署负载均衡和高可用

    一.负载均衡的部署 server1    haproxy (调度器) server2    apache server3    nginx 1)在server1上首先安装salt-minion服务.并 ...

    scheduleOnce

    //程序开始后延时2秒才开始addSprite函数 scheduleOnce(schedule_selector(Issue1305::addSprite), ); 转到定义: void CCNode ...

    展开全文
  • jstack 命令解读

    2021-04-01 17:31:30
    jstack 命令是JDK工具之一,使用该命令可以打印正在运行中 Java 进程的栈信息。 Usage: jstack [-l] <pid> (to connect to running process) jstack -F [-m] [-l] <pid> (to connect to a hung ...

    jstack 命令是JDK工具之一,使用该命令可以打印正在运行中 Java 进程的栈信息。

    Usage:
        jstack [-l] <pid>
            (to connect to running process)
        jstack -F [-m] [-l] <pid>
            (to connect to a hung process)
        jstack [-m] [-l] <executable> <core>
            (to connect to a core file)
    Options:
        -F 强制打印线程栈信息,在jstack <pid>命令没有响应的时候添加该选项可以实现强制打印
        -m  (mix)混合模式,可以打印 Java 栈和本地方法栈
        -l  (long listing)长列表模式. 额外打印关于锁的信息
    

    jstack用法

    首先使用 jps命令查看需要打印线程栈的java进程号。

    D:\Desktop>jps
    17984 Launcher
    9348 DeathLock
    

    我们这里链接到 9348 这个进程号上,使用下面命令:

    D:\Desktop>jstack 9348
    Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.281-b09 mixed mode):
    
    "DestroyJavaVM" #13 prio=5 os_prio=0 tid=0x0000018da5881000 nid=0x34c8 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
    "mythread2" #12 prio=5 os_prio=0 tid=0x0000018dc2547000 nid=0x2580 waiting on condition [0x000000468cdff000]
       java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x000000076b8dbf28> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
            at java.util.concurrent.locks.LockSupport.park(Unknown Source)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(Unknown Source)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(Unknown Source)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Unknown Source)
            at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(Unknown Source)
            at java.util.concurrent.locks.ReentrantLock.lock(Unknown Source)
            at DeathLock.lambda$deathLock$1(DeathLock.java:24)
            at DeathLock$$Lambda$2/1044036744.run(Unknown Source)
            at java.lang.Thread.run(Unknown Source)
    

    可以看到控制台打印出了线程的信息以及线程对应的堆栈信息。下面我们对打印结果进行逐行分析:

    java.lang.Thread.State: RUNNABLE 线程状态

    首先需要分析的便是线程状态,在 Java 中线程会分别对应着不同的线程状态,从创建线程的 NEW到销毁时的TERMINATED状态。在java.lang.Thread.State类中都有定义,想要分析源码的话可以打开该类进行查看。线程的状态有助于帮我们更好的分析线程的运行过程,下面贴一张图来描述线程之间状态的转换。

    private static boolean exit = false;
    // 在 new 一个线程对象后,该线程的状态为 NEW 状态
    Thread thread1 = new Thread(()->{
    	while(!exit){
    		// 在执行线程中代码时,线程的状态为 RUNNABLE 状态
    		System.out.println("current time is "+new Date())
    		// 在执行睡眠代码时,线程会进入 TIMED_WAITTING 状态,并让出 CPU ,等待时间唤醒
    		TimeUnit.SECONDS.sleep(1);
    	}
    });
    // 在 start 之后,该线程的状态会进入 RUNNABLE 状态,并且等待系统调度后运行
    thread1.start();
    

    在这里插入图片描述
    通过上述线程状态转移图可以帮助我们分析当前线程所处的状态以及他们运行逻辑。

    我们通过 jstack查看线程栈信息时通常看到的最多的是RUNNABLE,BLOCKED,WAITINGTIMED_WAITING这几种状态,我们一般看不到线程的NEWTERMINATED状态,是因为在代码的运行过程中这两种状态只占很小一部分,我们捕捉到这两种状态前这两种状态已经一闪而过了。

    "mythread2" #12 分析

    以线程名称开头,所有线程都会在第一行打印一些当前线程的运行信息。

    "main" #1 prio=5 os_prio=0 tid=0x0000000002e7e800 nid=0x2a1c in Object.wait() [0x0000000002f7f000]
       java.lang.Thread.State: WAITING (on object monitor)
    

    其中开头是线程名称,后面的为线程信息:
    #1 表示当前线程ID,从 main线程开始,JVM 根据线程创建的顺序为线程编号。
    priopriority优先级的缩写,表名了当前线程的优先级,取值范围为[1-10],默认为 5。在虚拟机进行线程调度的时候会参考该优先级为线程分配计算资源,这个数值越低越有优先获取到计算资源,一般不设置直接使用默认的优先级。
    os_prio为线程对应系统的优先级。
    nid 本地线程编号NativeID的缩写,对应JVM 虚拟机中线程映射在操作系统中的线程编号。我们可以使用 top 查看进程对应的线程情况进行相关映射。

    nid的作用及其使用方式

    如上面的描述nid表示的是线程对应的系统本地的线程编号

    线程锁解读

    当一个线程占有一个锁的时候,线程堆栈会打印一个-locked<0x22bffb60>
    在这里插入图片描述

    // 示例代码
    public class Main6 {
        private static ReentrantLock lock = new ReentrantLock();
    
        public static void main(String[] args) {
            final Thread task1 = new Thread(new Task());
            final Thread task2 = new Thread(new Task());
            task1.start();
            task2.start();
        }
        private static class Task implements Runnable {
            @Override
            public void run() {
                lock.lock();
                int i = 0;
                while (true) {
                    i++;
                }
            }
        }
    }
    
    

    当一个线程正在等在其他线程释放该锁,线程堆栈会打印一个-waiting to lock<0x22bffb60>
    在这里插入图片描述
    当一个线程占有一个锁,但又执行在该锁的wait上,线程堆栈中首先打印blocked,然后打印-waiting on <0x22c03c60>
    在这里插入图片描述

    // 示例代码
    public class Main7 {
        private static Object lock1 = new Object();
        private static Object lock2 = new Object();
    
        public static void main(String[] args) {
            final Thread task1 = new Thread(() -> {
                synchronized (lock1) {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock2) {
                        int i = 0;
                        while (true) {
                            i++;
                        }
                    }
                }
            });
            final Thread task2 = new Thread(() -> {
                synchronized (lock2) {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock1) {
                        int i = 0;
                        while (true) {
                            i++;
                        }
                    }
                }
            });
            task1.start();
            task2.start();
        }
    }
    
    

    使用 jstacktop -Hp获取目标线程的CPU使用情况

    通过 jstack 可以打印出当前进程的线程栈信息,但是我们无法获取到这些线栈的 CPU 占用情况,此时,我们可以使用另外一个bash命令 top 去排查高 CPU 占用的线程。
    首先使用 jps 命令获取目标 java 进程号:

    [ghimi@node01 ~]$ jps
    19332 Main7
    

    然后使用 top -Hp <pid>查看该进程下对应线程的CPU 使用情况:
    在这里插入图片描述
    这里如果我们想查看 PID19343且线程名称为Thread-1 的堆栈信息的话(很明显这是我们创建的线程)。
    首先我们需要将该线程好打印成 16进制的,可以使用电脑中自带的计算器,或者使用命令都可以:
    使用计算器计算线程的16进制:
    在这里插入图片描述
    使用命令行获取16进制:

    [ghimi@node01 ~]$ printf "%x\n" 19343
    4b8f
    

    接下来使用 jstack <pid> 查看线程堆栈信息:

    # 
    jstack 19332 | grep -10 4b8f
    

    在这里插入图片描述
    由此我们可以看到目标线程的线程堆栈信息了。

    使用 top -Hp <pid>查看目标进程下各个线程的 CPU 使用情况

    通过top -Hp <pid>可以查看该进程下各个线程的CPU使用情况。
    在这里插入图片描述

    使用 pstree 查看进程树

    通过命令 pstree 可以获取到系统当前运行过程中的进程树,像下面这样:

    # -p 选项表示显示详细的进程识别码
    pstree -p
    

    在这里插入图片描述

    使用 ps -Lf <pid>查看进程详细信息

    使用 ps -Lf <pid>可以查看目标进程及其线程的信息。
    在这里插入图片描述

    jvm 监控工具Liberica Mission Control

    类似于 Java Mission Control,这款工具可以用来监控正在运行当中的 Java 进程这款工具是由贝尔实验室开源的,大概长这样:
    在这里插入图片描述
    简单来看,这款工具能够帮助我们实时的监控虚拟机中进程正在运行的状态。这里不对该工具的使用方式做过多介绍,主要使用该工具去查看一下我们刚刚使用 jstack 命令打印得到的线程信息,由于该工具汉化做的非常好,所以我们可以通过该工具进行对照分析。
    在这里插入图片描述
    下载页面
    在这里插入图片描述

    参考资料

    java线程状态和状态切换
    jstack
    jvm工具-jstack使用
    jstack - 检测死锁、等待、CPU耗时
    JVM线程模型详解
    jstack日志线程分析
    JVM 调优之 jstack 找出最耗cpu的线程
    如何使用jstack分析线程状态

    展开全文
  • jstack命令解析

    2021-04-12 18:46:30
    jstack查看输出 /opt/java8/bin/jstack -l 28367 2019-06-25 15:04:46 Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.77-b03 mixed mode): "Attach Listener" #453 daemon prio=9 os_prio=0 tid=0x...

    高cpu,高内存的Java进程排查方法

    jstack查看输出

    /opt/java8/bin/jstack -l 28367
    2019-06-25 15:04:46
    Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.77-b03 mixed mode):
    
    "Attach Listener" #453 daemon prio=9 os_prio=0 tid=0x00007f9f94001000 nid=0xf30 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
       Locked ownable synchronizers:
            - None
    
    "grpc-default-executor-263" #452 daemon prio=5 os_prio=0 tid=0x00007f9f4c01f800 nid=0x9aa waiting on condition [0x00007f9f398bd000]
       java.lang.Thread.State: TIMED_WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000007400243f0> 
    
       Locked ownable synchronizers:
            - None

    jstack统计线程数

    /opt/java8/bin/jstack -l 28367 | grep 'java.lang.Thread.State' | wc -l

    查看cpu高

    • 代码中某个位置读取数据量较大,导致系统内存耗尽,从而导致Full GC次数过多,系统缓慢;
    • 代码中有比较耗CPU的操作,导致CPU过高,系统运行缓慢;

    另外有几种情况也会导致某个功能运行缓慢,但是不至于导致系统不可用:

    • 代码某个位置有阻塞性的操作,导致该功能调用整体比较耗时,但出现是比较随机的;
    • 某个线程由于某种原因而进入WAITING状态,此时该功能整体不可用,但是无法复现;
    • 由于锁使用不当,导致多个线程进入死锁状态,从而导致系统整体比较缓慢。

    对于这三种情况,通过查看CPU和系统内存情况是无法查看出具体问题的,因为它们相对来说都是具有一定阻塞性操作,CPU和系统内存使用情况都不高,但是功能却很慢

    top命令查看系统CPU的占用情况:top

    top命令查看呢该进程的各个线程运行情况:top -Hp 9

    替换进程id号为十六进制:# printf "%x\n" 10  

    定位cpu占用线程: jstack 进程id | grep  线程id十六进制 -A 30

    检查到死锁日志:

    "mythread2" #12 prio=5 os_prio=0 tid=0x0000000058ef7800 nid=0x1ab4 waiting on condition [0x0000000059f8f000]
       java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000000d602d610> (a java.util.concurrent.lock
    s.ReentrantLock$NonfairSync)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
    errupt(AbstractQueuedSynchronizer.java:836)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
    bstractQueuedSynchronizer.java:870)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
    tQueuedSynchronizer.java:1199)
            at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
    ck.java:209)
            at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
    
            at DeathLock$2.run(DeathLock.java:34)
    
       Locked ownable synchronizers:
            - <0x00000000d602d640> (a java.util.concurrent.locks.ReentrantLock$Nonfa
    irSync)
    
    "mythread1" #11 prio=5 os_prio=0 tid=0x0000000058ef7000 nid=0x3e68 waiting on condition [0x000000005947f000]
       java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000000d602d640> (a java.util.concurrent.lock
    s.ReentrantLock$NonfairSync)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
    errupt(AbstractQueuedSynchronizer.java:836)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
    bstractQueuedSynchronizer.java:870)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
    tQueuedSynchronizer.java:1199)
            at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
    ck.java:209)
            at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
    
            at DeathLock$1.run(DeathLock.java:22)
    
       Locked ownable synchronizers:
            - <0x00000000d602d610> (a java.util.concurrent.locks.ReentrantLock$Nonfa
    irSync)
    
    
    Found one Java-level deadlock:
    =============================
    "mythread2":
      waiting for ownable synchronizer 0x00000000d602d610, (a java.util.concurrent.l
    ocks.ReentrantLock$NonfairSync),
      which is held by "mythread1"
    "mythread1":
      waiting for ownable synchronizer 0x00000000d602d640, (a java.util.concurrent.l
    ocks.ReentrantLock$NonfairSync),
      which is held by "mythread2"
    
    Java stack information for the threads listed above:
    ===================================================
    "mythread2":
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000000d602d610> (a java.util.concurrent.lock
    s.ReentrantLock$NonfairSync)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
    errupt(AbstractQueuedSynchronizer.java:836)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
    bstractQueuedSynchronizer.java:870)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
    tQueuedSynchronizer.java:1199)
            at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
    ck.java:209)
            at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
    
            at DeathLock$2.run(DeathLock.java:34)
    "mythread1":
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000000d602d640> (a java.util.concurrent.lock
    s.ReentrantLock$NonfairSync)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
    errupt(AbstractQueuedSynchronizer.java:836)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
    bstractQueuedSynchronizer.java:870)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
    tQueuedSynchronizer.java:1199)
            at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
    ck.java:209)
            at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
    
            at DeathLock$1.run(DeathLock.java:22)
    
    Found 1 deadlock.

    如果通过jstack命令看到以下日志

    "main" #1 prio=5 os_prio=0 tid=0x00007f8718009800 nid=0xb runnable [0x00007f871fe41000]
       java.lang.Thread.State: RUNNABLE
        at com.aibaobei.chapter2.eg2.UserDemo.main(UserDemo.java:9)
    
    "VM Thread" os_prio=0 tid=0x00007f871806e000 nid=0xa runnable
    

    这里的VM Thread一行的最后显示nid=0xa,这里nid的意思就是操作系统线程id的意思。而VM Thread指的就是垃圾回收的线程。这里我们基本上可以确定,当前系统缓慢的原因主要是垃圾回收过于频繁,导致GC停顿时间较长。我们通过如下命令可以查看GC的情况:

    root@8d36124607a0:/# jstat -gcutil 9 1000 10
      S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT
      0.00   0.00   0.00  75.07  59.09  59.60   3259    0.919  6517    7.715    8.635
      0.00   0.00   0.00   0.08  59.09  59.60   3306    0.930  6611    7.822    8.752
      0.00   0.00   0.00   0.08  59.09  59.60   3351    0.943  6701    7.924    8.867
      0.00   0.00   0.00   0.08  59.09  59.60   3397    0.955  6793    8.029    8.984
    

    这里的VM Thread一行的最后显示nid=0xa,这里nid的意思就是操作系统线程id的意思。而VM Thread指的就是垃圾回收的线程。这里我们基本上可以确定,当前系统缓慢的原因主要是垃圾回收过于频繁,导致GC停顿时间较长。我们通过如下命令可以查看GC的情况:

    root@8d36124607a0:/# jstat -gcutil 9 1000 10
      S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT
      0.00   0.00   0.00  75.07  59.09  59.60   3259    0.919  6517    7.715    8.635
      0.00   0.00   0.00   0.08  59.09  59.60   3306    0.930  6611    7.822    8.752
      0.00   0.00   0.00   0.08  59.09  59.60   3351    0.943  6701    7.924    8.867
      0.00   0.00   0.00   0.08  59.09  59.60   3397    0.955  6793    8.029    8.984
    

    可以看到,这里FGC指的是Full GC数量,这里高达6793,而且还在不断增长。从而进一步证实了是由于内存溢出导致的系统缓慢。

    Java高CPU占用排查步骤

    • top:找到占用CPU高的进程PID
    • jstack PID >> java_stack.log:导出CPU占用高进程的线程栈
    • top -Hp PID:找出PID的进程占用CPU过高的线程tid。(或使用命令 ps -mp PID -o THREAD,tid,time | sort -rn | less)
    • printf “%x\n” tid:将需要的线程ID转换为16进制格式。
    • less java_stack.log:查找转换成为16进制的线程TID,找到对应的线程栈,分析并处理问题。

    Java高内存占用排查步骤

    • top:找到占用内存(RES列)高的Java进程PID。
    • jmap -heap PID:查看heap内存使用情况。
    • jps -lv :查看JVM参数配置。
    • jstat -gc PID 1000:收集每秒堆的各个区域具体占用大小的gc信息。
    • jmap -dump:live,format=b,file=heap_dump.hprof PID :导出堆文件。
    • 使用MAT打开堆文件,分析问题。

    Java堆外内存泄漏排查步骤

    • top:找到占用内存(RES列)较高的Java进程PID。
    • jstat -gcutil PID 1000 查看每秒各个区域占堆百分比,若gc正常,则分析堆外内存使用情况。
    • jcmd PID VM.native_memory detail,该命令需要添加JVM参数 -XX:NativeMemoryTracking=detail,并重启Java进程才能生效,该命令会显示内存使用情况,查看输出结果,总的committed的内存是否小于物理内存(RES),因为jcmd命令显示的内存包含堆内内存、Code区域、通过unsafe.allocateMemory和DirectByteBuffer申请的内存,但是不包含其他Native Code(C代码)申请的堆外内存。
    • pmap -x PID | sort -rn -k 3:查看内存分布,是否有地址空间不在jcmd命令所给出的地址空间中。
    • 用工具定位堆外内存,如gperftools、gdb、strace等。

    主要是怕这位大佬的文章突然看不到了,搬运备份学习。搬运工自这位大佬:https://blog.csdn.net/baiye_xing/article/details/90483169

     

    展开全文
  • jstack命令详解

    2021-03-08 16:01:02
    jstack命令可以用来查看运行的Java进程下,多线程的运行情况,语句如“[root@admin ~]# jstack 43616Full thread dump Java HotSpot(TM) 64-Bit Server...”。Java jstack 命令详解Java 中 jstack 命令可以用来查看...

    jstack命令可以用来查看运行的Java进程下,多线程的运行情况,语句如“[root@admin ~]# jstack 43616

    Full thread dump Java HotSpot(TM) 64-Bit Server...”。

    48ecf51d553e1437d12cbae27149ef50.png

    Java jstack 命令详解

    Java 中 jstack 命令可以用来查看运行的 Java 进程下,多线程的运行情况,我们用一个死锁的例子来看:

    比如下面这段死锁的代码:public class DeadLock {

    private static Object objA = new Object();

    private static Object objB = new Object();

    public static void main(String[] args) {

    Thread thread1 = new Thread(new Thread1());

    Thread thread2 = new Thread(new Thread2());

    thread1.start();

    thread2.start();

    }

    private static class Thread1 implements Runnable{

    @Override

    public void run() {

    synchronized (objA) {

    System.out.println("线程1得到A对象的锁");

    try {

    Thread.sleep(3000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    synchronized (objB) {

    System.out.println("线程1得到B对象的锁");

    }

    }

    }

    }

    private static class Thread2 implements Runnable{

    @Override

    public void run() {

    synchronized (objB) {

    System.out.println("线程2得到B对象的锁");

    try {

    Thread.sleep(3000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    synchronized (objA) {

    System.out.println("线程2得到A对象的锁");

    }

    }

    }

    }

    }

    当然,运行结果只能看到两个线程只拿到了一个锁,在一直等待对方的锁。线程1得到A对象的锁

    线程2得到B对象的锁

    我们可以使用 jps 来查看对应的 PID ,然后使用 jstack 来查看其线程情况:[root@admin ~]# jps

    42576 Jps

    43616 DeadLock[root@admin ~]# jstack 43616

    Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.45-b08 mixed mode):

    "DestroyJavaVM" prio=6 tid=0x00000000047c1000 nid=0x9878 waiting on condition [0x0000000000000000]

    java.lang.Thread.State: RUNNABLE

    "Thread-1" prio=6 tid=0x0000000010aa3000 nid=0xafa0 waiting for monitor entry [0x000000001105f000]

    java.lang.Thread.State: BLOCKED (on object monitor)

    at com.zaimeibian.Test$Thread2.run(Test.java:46)

    - waiting to lock <0x00000007c099cc20> (a java.lang.Object)

    - locked <0x00000007c099cc30> (a java.lang.Object)

    at java.lang.Thread.run(Thread.java:744)

    "Thread-0" prio=6 tid=0x0000000010aa2800 nid=0xae74 waiting for monitor entry [0x0000000010f5f000]

    java.lang.Thread.State: BLOCKED (on object monitor)

    at com.zaimeibian.Test$Thread1.run(Test.java:27)

    - waiting to lock <0x00000007c099cc30> (a java.lang.Object)

    - locked <0x00000007c099cc20> (a java.lang.Object)

    at java.lang.Thread.run(Thread.java:744)

    "Service Thread" daemon prio=6 tid=0x000000000f10a000 nid=0x9a8c runnable [0x0000000000000000]

    java.lang.Thread.State: RUNNABLE

    "C2 CompilerThread1" daemon prio=10 tid=0x000000000f109800 nid=0xaf28 waiting on condition [0x0000000000000000]

    java.lang.Thread.State: RUNNABLE

    "C2 CompilerThread0" daemon prio=10 tid=0x000000000f105800 nid=0x85dc waiting on condition [0x0000000000000000]

    java.lang.Thread.State: RUNNABLE

    "Attach Listener" daemon prio=10 tid=0x000000000f104800 nid=0xac04 waiting on condition [0x0000000000000000]

    java.lang.Thread.State: RUNNABLE

    "Signal Dispatcher" daemon prio=10 tid=0x000000000f102000 nid=0xa678 runnable [0x0000000000000000]

    java.lang.Thread.State: RUNNABLE

    "Finalizer" daemon prio=8 tid=0x000000000f0bd000 nid=0xaed8 in Object.wait() [0x000000001045f000]

    java.lang.Thread.State: WAITING (on object monitor)

    at java.lang.Object.wait(Native Method)

    - waiting on <0x00000007c0905568> (a java.lang.ref.ReferenceQueue$Lock)

    at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)

    - locked <0x00000007c0905568> (a java.lang.ref.ReferenceQueue$Lock)

    at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)

    at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:189)

    "Reference Handler" daemon prio=10 tid=0x000000000f0b2000 nid=0xaedc in Object.wait() [0x000000001035f000]

    java.lang.Thread.State: WAITING (on object monitor)

    at java.lang.Object.wait(Native Method)

    - waiting on <0x00000007c09050f0> (a java.lang.ref.Reference$Lock)

    at java.lang.Object.wait(Object.java:503)

    at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)

    - locked <0x00000007c09050f0> (a java.lang.ref.Reference$Lock)

    "VM Thread" prio=10 tid=0x000000000f0b0000 nid=0xaef0 runnable

    "GC task thread#0 (ParallelGC)" prio=6 tid=0x00000000047d6000 nid=0xacb0 runnable

    "GC task thread#1 (ParallelGC)" prio=6 tid=0x00000000047d8000 nid=0xaee0 runnable

    "GC task thread#2 (ParallelGC)" prio=6 tid=0x00000000047d9800 nid=0xaed4 runnable

    "GC task thread#3 (ParallelGC)" prio=6 tid=0x00000000047db000 nid=0xac54 runnable

    "VM Periodic Task Thread" prio=10 tid=0x000000000f132000 nid=0xaff0 waiting on condition

    JNI global references: 105

    Found one Java-level deadlock:

    =============================

    "Thread-1":

    waiting to lock monitor 0x000000000f0ba488 (object 0x00000007c099cc20, a java.lang.Object),

    which is held by "Thread-0"

    "Thread-0":

    waiting to lock monitor 0x000000000f0bcf28 (object 0x00000007c099cc30, a java.lang.Object),

    which is held by "Thread-1"

    Java stack information for the threads listed above:

    ===================================================

    "Thread-1":

    at com.zaimeibian.Test$Thread2.run(Test.java:46)

    - waiting to lock <0x00000007c099cc20> (a java.lang.Object)

    - locked <0x00000007c099cc30> (a java.lang.Object)

    at java.lang.Thread.run(Thread.java:744)

    "Thread-0":

    at com.zaimeibian.Test$Thread1.run(Test.java:27)

    - waiting to lock <0x00000007c099cc30> (a java.lang.Object)

    - locked <0x00000007c099cc20> (a java.lang.Object)

    at java.lang.Thread.run(Thread.java:744)

    Found 1 deadlock.

    我们可以看到 jstack 打印出了线程的状态,而且发现一个死锁。

    另外,线程状态有以下几种:

    - RUNNABLE 线程运行中或 I/O 等待

    - BLOCKED 线程在等待 monitor 锁( synchronized 关键字)

    - TIMED_WAITING 线程在等待唤醒,但设置了时限

    - WAITING 线程在无限等待唤醒

    展开全文
  • jstack命令

    千次阅读 2016-04-22 00:08:03
    jstack(Stack Trace for Java)命令用于生成JVM进程当前时刻的线程的调用堆栈,可以用来定位线程间死锁、锁等待、等待外部资源等 jstack 命令格式 jstack [option] pid -F 当正常jstack正常的请求不被响应...
  • 使用jstack命令dump线程信息

    千次阅读 2019-04-25 18:45:56
    想要通过jstack命令来分析线程的情况的话,首先要知道线程都有哪些状态,下面这些状态是我们使用jstack命令查看线程堆栈信息时可能会看到的线程的几种状态。 NEW,未启动的。不会出现在Dump中。 RUNNABLE,在虚拟机内...
  • jstack 命令常用参数说明1)options:executable Java executable from which the core dump was produced.(可能是产生core dump的java可执行程序)core 将被打印信息的core dump文件remote-hostname-or-IP 远程debug...
  • jdk-jstack命令

    2020-09-09 16:39:29
    jstack命令用来生成JVM中的线程快照(thread dump),其中包含有每个线程的方法调用栈以及其状态、锁信息等。其用法说明如下所示。 说明一下三个参数的含义: -F:如果正常执行jstack命令没有响应(比如进程hung住...
  • Java jstack 命令详解

    千次阅读 2018-07-07 19:41:48
    Java 中 jstack 命令可以用来查看运行的 Java 进程下,多线程的运行情况,我们用一个死锁的例子来看: 比如下面这段死锁的代码: public class DeadLock { private static Object objA = new Object(); ...
  • Linux jstack命令

    万次阅读 2019-06-18 09:20:48
    一、命令 如果java程序崩溃生成core文件,jstack工具可以用来获得core文件的java stack和native stack的信息,从而可以轻松地知道java程序是如何崩溃和在程序何处发生问题。另外,jstack工具还可以附属到正在运行的...
  • jstack 命令详解

    万次阅读 2019-04-09 19:01:46
    一、jstack 命令参数 二、jstack解决问题 1、死循环导致cpu飙高 死循环的例子:https://blog.csdn.net/goldenfish1919/article/details/8755378 步骤:查找进程-》查找线程-》分析threadDump日志-》找出问题代码...
  • jstack命令的使用

    2021-03-03 11:21:57
    jstack用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合,生成线程快照的主要目的是定位线程出现长时间停顿的原因,如线程间死锁、死循环、请求外部资源导致的...
  • 前言 很久没有写过与JVM相关的文章了。今天搬砖有点累,不太想啃源码,写一篇实用性比较强...但是,我们也有必要了解JVM原生提供的那些命令行工具,本文就针对常用的jstack命令做个简单的总结,顺便聊一些与Java线程...
  • 怕什么真理无穷进一步有近一步的欢喜前情预告在介绍jstack之前,先简单介绍一下jps。因为jps使用相对简单,各位看官看一下便知。jps的作用是显示当前系统的java进程情况,及其id号...
  • jstack命令的主要作用是打印指定Java进程中每一个线程的工作状态,以及每个线程栈当前的方法执行顺序等详细情况。为什么jstack命令不和jmap、jinfo、jstat等命令一同讲解,而要单独成文呢?因为通过jstack命令给出的...
  • 1、当系统cpu占用率过高时,可以通过top命令查看当前cpu占用率最高的线程 可以看到排在第一位的pid为...这里通过jstack 命令查看进程22705的cpu占用,并找到线程Id为58e6的日志 在这里可以看到当前java线程的状态
  • jstack命令使用

    2018-05-03 21:00:15
    jstack &lt;pid&gt; :导出该进程的堆栈信息,对于解决问题是非常有帮助的。 如果java程序崩溃生成core文件,jstack工具可以用来获得core文件的java stack和native stack的信息,从而可以轻松地知道java...
  • 使用jstack命令,排查线程死锁问题

    千次阅读 2020-06-21 18:34:56
    使用jstack命令,排查线程死锁问题。 jstack是什么? jstack是java虚拟机自带的一种堆栈跟踪工具。jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息 jstack有什么作用 jstack主要用于...
  • OpenJDK利用jstack命令打印堆栈信息

    千次阅读 2020-09-05 11:09:18
    程序需要对一个大文本进行处理,最后发现一直在处理中,cpu占用率一直为100%,大概能猜想出问题所在,只是借用 jstack 打印堆栈信息用以佐证。 jstack佐证 执行 top 找出占用cpu最高的java进程id //10 执行 top -...
  • jstack命令使用jstack日志查看

    千次阅读 2021-02-05 11:12:33
    jstack是java虚拟机自带的一种堆栈跟踪工具。 jstack用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合,生成线程快照的主要目的是定位线程出现长时间停顿的...
  • 当linux出现cpu被java程序消耗过高时,我们使用jdk自带的jstack来分析: 1.使用top命令,找到cpu消耗很高的进程pid (jps或或ps -ef|grep java也可以查看java进程) 语法:top 2、查看高负载进程下的高负载线程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,433
精华内容 10,173
关键字:

jstack命令

友情链接: Arduino-XBee-01.rar