如何分析java Thread DUMP

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了如何分析java Thread DUMP相关的知识，希望对你有一定的参考价值。

一、Thread Dump介绍
1.1什么是Thread Dump？
Thread Dump是非常有用的诊断Java应用问题的工具。每一个Java虚拟机都有及时生成所有线程在某一点状态的thread-dump的能力，虽然各个 Java虚拟机打印的thread dump略有不同，但是大多都提供了当前活动线程的快照，及JVM中所有Java线程的堆栈跟踪信息，堆栈信息一般包含完整的类名及所执行的方法，如果可能的话还有源代码的行数。

1.2 Thread Dump特点
1. 能在各种操作系统下使用
2. 能在各种Java应用服务器下使用
3. 可以在生产环境下使用而不影响系统的性能
4. 可以将问题直接定位到应用程序的代码行上

1.3 Thread Dump 能诊断的问题
1. 查找内存泄露，常见的是程序里load大量的数据到缓存；
2. 发现死锁线程；

1.4如何抓取Thread Dump
一般当服务器挂起,崩溃或者性能底下时,就需要抓取服务器的线程堆栈(Thread Dump)用于后续的分析. 在实际运行中，往往一次 dump的信息，还不足以确认问题。为了反映线程状态的动态变化，需要接连多次做threaddump，每次间隔10-20s，建议至少产生三次 dump信息，如果每次 dump都指向同一个问题，我们才确定问题的典型性。

有很多方式可用于获取ThreadDump, 下面列出一部分获取方式：
操作系统命令获取ThreadDump:
Windows:
1.转向服务器的标准输出窗口并按下Control + Break组合键, 之后需要将线程堆栈复制到文件中；
UNIX/ Linux：
首先查找到服务器的进程号(process id), 然后获取线程堆栈.
1. ps –ef | grep java
2. kill -3 <pid>
注意：一定要谨慎, 一步不慎就可能让服务器进程被杀死。kill -9 命令会杀死进程。

JVM 自带的工具获取线程堆栈:
JDK自带命令行工具获取PID，再获取ThreadDump:
1. jps 或 ps –ef|grepjava (获取PID)
2. jstack [-l ]<pid> | tee -a jstack.log (获取ThreadDump)

二、java线程的状态转换介绍(为后续分析做准备)

2.1 新建状态（New）
用new语句创建的线程处于新建状态，此时它和其他Java对象一样，仅仅在堆区中被分配了内存。
2.2 就绪状态（Runnable）
当一个线程对象创建后，其他线程调用它的start()方法，该线程就进入就绪状态，Java虚拟机会为它创建方法调用栈和程序计数器。处于这个状态的线程位于可运行池中，等待获得CPU的使用权。
2.3 运行状态（Running）
处于这个状态的线程占用CPU，执行程序代码。只有处于就绪状态的线程才有机会转到运行状态。
2.4 阻塞状态（Blocked）
阻塞状态是指线程因为某些原因放弃CPU，暂时停止运行。当线程处于阻塞状态时，Java虚拟机不会给线程分配CPU。直到线程重新进入就绪状态，它才有机会转到运行状态。
阻塞状态可分为以下3种：
1）位于对象等待池中的阻塞状态（Blocked in object’s wait pool）：当线程处于运行状态时，如果执行了某个对象的wait()方法，Java虚拟机就会把线程放到这个对象的等待池中，这涉及到“线程通信”的内容。
2）位于对象锁池中的阻塞状态（Blocked in object’s lock pool）：当线程处于运行状态时，试图获得某个对象的同步锁时，如果该对象的同步锁已经被其他线程占用，Java虚拟机就会把这个线程放到这个对象的锁池中，这涉及到“线程同步”的内容。 参考技术A 当Java Web程序运行变慢，或者发生故障时，需要使用Thread Dumps. 如果觉得ThreadDumps非常复杂，这篇文章很可能帮助你。将会分析Java中的线程，线程如何创建的，如何管理线程，怎么从运行中的程序中dump 线程，最后怎么分析他们得到阻塞和存在瓶颈的线程。本回答被提问者采纳 参考技术B 当Java Web程序运行变慢，或者发生故障时，需要使用Thread Dumps. 如果你觉得ThreadDumps非常复杂，这篇文章很可能帮助你。将会分析Java中的线程，线程如何创建的，如何管理线程，怎么从运行中的程序中dump 线程，最后怎么分析他们得到阻塞和存在瓶颈的线程。本文是在应用程序调试下得到的结果。

Java和线程
一个web server使用几十到几百条线程去处理大量的并发用户。如果多条线程使用共享的资源，无法避免线程之间对数据的竞争，有时候还会发生死锁。

线程竞争是web程序上不同的线程去访问共享资源，一条线程等待另外线程释放锁。例如，在记录log的时候，线程记录log时，必须先获得锁，然后去再访问共享资源。

死锁是一种特殊的线程竞争，两个或多个线程要完成自己的任务，都要必须要等待其他的线程完成他们的任务。

线程竞争会带来各种不同的问题，为了分析这些问题，需要使用Thread Dump。Thread Dump记录了每个线程真正的状态。

Java线程的背景

线程同步

多条线程之间可以同时执行，为了确保多线程在使用共享资源上面的通用性，使用线程同步保证在同一时间只能有一条线程可以访问共享资源。
线程同步在Java中可以使用监视器。每个Java对象都有一个监视器，这个监视器只能被一个线程拥有。当一个线程要获得另外线程拥有的监视器时，需要进入等待队列直到线程释放监视器。

线程的状态
为了分析Thread Dump ，需要先了解线程的状态。线程的状态是在java.lang.Thread.State中。

NEW:线程被创建但是还没有被执行
RUNNABLE:线程正在占用cpu并且在执行任务
BLOCKED:线程为了获得监视器需要等待其他线程释放锁
WAITING:调用了wait，join，park方法使线程等待-无限期等待
TIMED_WAITING:调用了sleep，wait，join，park方法使线程等待--有限期等待

线程类型
java中线程可以分为两种：
1. 后台线程

2. 非后台线程

当没有其他的非后台线程运行时后台线程将会终止。即使你不创建线程，java应用默认也会创建很多线程。这些大多数都是后台线程，主要为了执行gc或者jmx等类型的任务
从 'static void main(String[] args)’方法中开启的线程叫做非后台线程，当这些线程停止时，其他的所有后台线程也会停止()
获得一个Thread Dump
将会介绍三种常用的方法。请注意还会有其他很多方法可以获取Thread Dump。一个Thread dump仅仅可以显示测量时的线程状态。所以为了查看线程状态的变化，建议5到10次，每次间隔5秒。
使用jstack获得Thread　Dump
通过使用jsp命令来获得当前正在运行的Java程序的PID
[user@linux ~]$ jps -v 25780 RemoteTestRunner -Dfile.encoding=UTF-8 25590 sub.rmi.registry.RegistryImpl 2999 -Dapplication.home=/home1/user/java/jdk.1.6.0_24 -Xms8m 26300 sun.tools.jps.Jps -mlvV -Dapplication.home=/home1/user/java/jdk.1.6.0_24 -Xms8m

使用PID作为jstack的参数获得Thread　Dump
[user@linux ~]$ jstack -f 5824
使用jVisualVM获得Thread　Dump
通过使用jVisualVm来获得Thread　Dump

左边的标记，当前正在运行的进程。点击你想查看的进程，选择现场选项来查看实时的线程信息。点击Thread　Dump右边的按钮来获得Thread　Dump文件
在Linux终端中生成
通过使用ps　－ef命令去获得当前正在运行的Java进程
[user@linux ~]$ ps - ef | grep java

user 2477 1 0 Dec23 ? 00:10:45 ...
user 25780 25361 0 15:02 pts/3 00:00:02 ./jstatd -J -Djava.security.policy=jstatd.all.policy -p 2999
user 26335 25361 0 15:49 pts/3 00:00:00 grep java
Use the extracted pid as the parameter of kill –SIGQUIT(3) to obtain a thread dump.
Thread Information from the Thread Dump File
"pool-1-thread-13" prio=6 tid=0x000000000729a000 nid=0x2fb4 runnable [0x0000000007f0f000] java.lang.Thread.State: RUNNABLE at java.net.SocketInputStream.socketRead0(Native Method) at java.net.SocketInputStream.read(SocketInputStream.java:129) at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:264) at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:306) at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:158) - locked <0x0000000780b7e688> (a java.io.InputStreamReader) at java.io.InputStreamReader.read(InputStreamReader.java:167) at java.io.BufferedReader.fill(BufferedReader.java:136) at java.io.BufferedReader.readLine(BufferedReader.java:299) - locked <0x0000000780b7e688> (a java.io.InputStreamReader) at java.io.BufferedReader.readLine(BufferedReader.java:362)

Thread　name：当使用　Java．lang．Thread类去生成一个线程，将被命名为Thre－（Number），然而当使用java．util．concurrent，ThreadFactory类，将会被命名为pool－（Number）－thread－（Number）
Priority：表示线程的优先级
Thread ID：代表线程的唯一id。（通过线程id可以获得一些有用的信息，包括cpu使用率，或者内存使用率）
Thread　status：代表线程的状态
Thread　callstack：代表线程调用的堆栈信息

Thread　Dump模式的类型
当无法获得一个锁（阻塞）
当一个线程占领住锁而其他线程无法获得这个锁，而导致应用程序所有的性能都下降。

如何抓取分析Thread Dump

一、抓取

1. ps –ef  | grep java

2. jstack -l <pid> > 111.txt

二、分析

jstack Dump 日志文件中的线程状态

dump 文件里，值得关注的线程状态有：

  1. 死锁，Deadlock（重点关注） 

  2. 执行中，Runnable   

  3. 等待资源，Waiting on condition（重点关注） 

  4. 等待获取监视器，Waiting on monitor entry（重点关注）

  5. 暂停，Suspended

  6. 对象等待中，Object.wait() 或 TIMED_WAITING

  7. 阻塞，Blocked（重点关注）  

  8. 停止，Parked

下面我们先从第一个例子开始分析，然后再列出不同线程状态的含义以及注意事项，最后再补充两个实例。

综合示范一：Waiting to lock 和 Blocked

实例如下：

"RMI TCP Connection(267865)-172.16.5.25" daemon prio=10 tid=0x00007fd508371000 nid=0x55ae waiting for monitor entry [0x00007fd4f8684000]

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

at org.apache.log4j.Category.callAppenders(Category.java:201)

- waiting to lock <0x00000000acf4d0c0> (a org.apache.log4j.Logger)

at org.apache.log4j.Category.forcedLog(Category.java:388)

at org.apache.log4j.Category.log(Category.java:853)

at org.apache.commons.logging.impl.Log4JLogger.warn(Log4JLogger.java:234)

at com.tuan.core.common.lang.cache.remote.SpyMemcachedClient.get(SpyMemcachedClient.java:110)

……

1）线程状态是 Blocked，阻塞状态。说明线程等待资源超时！

2）“ waiting to lock <0x00000000acf4d0c0>”指，线程在等待给这个 0x00000000acf4d0c0 地址上锁（英文可描述为：trying to obtain  0x00000000acf4d0c0 lock）。

3）在 dump 日志里查找字符串 0x00000000acf4d0c0，发现有大量线程都在等待给这个地址上锁。如果能在日志里找到谁获得了这个锁（如locked < 0x00000000acf4d0c0 >），就可以顺藤摸瓜了。

4）“waiting for monitor entry”说明此线程通过 synchronized(obj) {……} 申请进入了临界区，从而进入了下图1中的“Entry Set”队列，但该 obj 对应的 monitor 被其他线程拥有，所以本线程在 Entry Set 队列中等待。

5）第一行里，"RMI TCP Connection(267865)-172.16.5.25"是 Thread Name 。tid指Java Thread id。nid指native线程的id。prio是线程优先级。[0x00007fd4f8684000]是线程栈起始地址。

 

Dump文件中的线程状态含义及注意事项

含义如下所示：

  • Deadlock：死锁线程，一般指多个线程调用间，进入相互资源占用，导致一直等待无法释放的情况。

  • Runnable：一般指该线程正在执行状态中，该线程占用了资源，正在处理某个请求，有可能正在传递SQL到数据库执行，有可能在对某个文件操作，有可能进行数据类型等转换。

  • Waiting on condition：等待资源，或等待某个条件的发生。具体原因需结合 stacktrace来分析。


    • 一种情况是网络非常忙，几乎消耗了所有的带宽，仍然有大量数据等待网络读写；

    • 另一种情况也可能是网络空闲，但由于路由等问题，导致包无法正常的到达。

    • 如果堆栈信息明确是应用代码，则证明该线程正在等待资源。一般是大量读取某资源，且该资源采用了资源锁的情况下，线程进入等待状态，等待资源的读取。

    • 又或者，正在等待其他线程的执行等。

    • 如果发现有大量的线程都在处在 Wait on condition，从线程 stack看，正等待网络读写，这可能是一个网络瓶颈的征兆。因为网络阻塞导致线程无法执行。


    • 另外一种出现 Wait on condition的常见情况是该线程在 sleep，等待 sleep的时间到了时候，将被唤醒。

  • Blocked：线程阻塞，是指当前线程执行过程中，所需要的资源长时间等待却一直未能获取到，被容器的线程管理器标识为阻塞状态，可以理解为等待资源超时的线程。

  • Waiting for monitor entry 和 in Object.wait()：Monitor是 Java中用以实现线程之间的互斥与协作的主要手段，它可以看成是对象或者 Class的锁。每一个对象都有，也仅有一个 monitor。从下图1中可以看出，每个 Monitor在某个时刻，只能被一个线程拥有，该线程就是 “Active Thread”，而其它线程都是 “Waiting Thread”，分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”，而在 “Wait Set”中等待的线程状态是 “in Object.wait()”。

技术分享技术分享

图1 A Java Monitor

 

综合示范二：Waiting on condition 和 TIMED_WAITING

实例如下：

"RMI TCP Connection(idle)" daemon prio=10 tid=0x00007fd50834e800 nid=0x56b2 waiting on condition [0x00007fd4f1a59000]

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

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

- parking to wait for  <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)

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

at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:424)

at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:323)

at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:874)

at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:945)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:907)

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

1）“TIMED_WAITING (parking)”中的 timed_waiting 指等待状态，但这里指定了时间，到达指定的时间后自动退出等待状态；parking指线程处于挂起中。


2）“waiting on condition”需要与堆栈中的“parking to wait for  <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)”结合来看。首先，本线程肯定是在等待某个条件的发生，来把自己唤醒。其次，SynchronousQueue 并不是一个队列，只是线程之间移交信息的机制，当我们把一个元素放入到 SynchronousQueue 中时必须有另一个线程正在等待接受移交的任务，因此这就是本线程在等待的条件。

3）别的就看不出来了。

综合示范三：in Obejct.wait() 和 TIMED_WAITING

实例如下：

"RMI RenewClean-[172.16.5.19:28475]" daemon prio=10 tid=0x0000000041428800 nid=0xb09 in Object.wait() [0x00007f34f4bd0000]

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

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

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

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

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

at sun.rmi.transport.DGCClient$EndpointEntry$RenewCleanThread.run(DGCClient.java:516)

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

1）“TIMED_WAITING (on object monitor)”，对于本例而言，是因为本线程调用了 java.lang.Object.wait(long timeout) 而进入等待状态。

2）“Wait Set”中等待的线程状态就是“ in Object.wait() ”。当线程获得了 Monitor，进入了临界区之后，如果发现线程继续运行的条件没有满足，它则调用对象（一般就是被 synchronized 的对象）的 wait() 方法，放弃了 Monitor，进入 “Wait Set”队列。只有当别的线程在该对象上调用了 notify() 或者 notifyAll() ，“ Wait Set”队列中线程才得到机会去竞争，但是只有一个线程获得对象的 Monitor，恢复到运行态。 

3）RMI RenewClean 是 DGCClient 的一部分。DGC 指的是 Distributed GC，即分布式垃圾回收。

4）请注意，是先 locked <0x00000000aa672478>，后 waiting on <0x00000000aa672478>，之所以先锁再等同一个对象，请看下面它的代码实现：

static private class  Lock { };

private Lock lock = new Lock();

public Reference<? extends T> remove(long timeout)

{

    synchronized (lock) {

        Reference<? extends T> r = reallyPoll();

        if (r != null) return r;

        for (;;) {

            lock.wait(timeout);

            r = reallyPoll();

            ……

       }

}

即，线程的执行中，先用 synchronized 获得了这个对象的 Monitor（对应于  locked <0x00000000aa672478> ）；当执行到 lock.wait(timeout);，线程就放弃了 Monitor 的所有权，进入“Wait Set”队列（对应于  waiting on <0x00000000aa672478> ）。

5）从堆栈信息看，是正在清理 remote references to remote objects ，引用的租约到了，分布式垃圾回收在逐一清理呢。


本文出自 “风之痕_雪虎” 博客，请务必保留此出处http://snowtiger.blog.51cto.com/12931578/1952333

以上是关于如何分析java Thread DUMP的主要内容，如果未能解决你的问题，请参考以下文章

如何分析Thread Dump

如何分析Thread Dump

[JAVA]JAVA章4 Thread Dump如何分析

如何使用thread dump和分析Thread dump？

如何使用thread dump和分析Thread dump？

源码分析：Java中的Thread的创建和运行