java-jvm-jstack

jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息，如果是在64位机器上，需要指定选项"-J-d64"，Windows的jstack使用方式只支持以下的这种方式：
jstack [-l] pid
jstack [ option ] [server-id@]remote-hostname-or-IP


基本参数：
-F当’jstack [-l] pid’没有相应的时候强制打印栈信息
-l长列表. 打印关于锁的附加信息,例如属于java.util.concurrent的ownable synchronizers列表.
-m打印java和native c/c++框架的所有栈信息.

注意：-F参数 一般不要加，它是取当前挂起的线程信息，很多东西拿不到

注意：此命令会列出系统存在的死锁

Java代码 

1. sudo jstack -F  27409 > data.txt  
2. sudo jstack -J-d64 -F  27409  

输出：

Java代码 

1. Deadlock Detection:  
2.   
3. No deadlocks found.  
4.   
5. Thread 2768: (state = BLOCKED)  
6.  - sun.misc.Unsafe.park(boolean, long) @bci=0 (Compiled frame; information may be imprecise)  
7.  - java.util.concurrent.locks.LockSupport.parkNanos(java.lang.Object, long) @bci=20, line=226 (Compiled frame)  
8.  - java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(long) @bci=68, line=2082 (Compiled frame)  
9.  - java.util.concurrent.ArrayBlockingQueue.poll(long, java.util.concurrent.TimeUnit) @bci=49, line=389 (Compiled frame)  
10.  - java.util.concurrent.ThreadPoolExecutor.getTask() @bci=141, line=1068 (Compiled frame)  
11.  - java.util.concurrent.ThreadPoolExecutor.runWorker(java.util.concurrent.ThreadPoolExecutor$Worker) @bci=26, line=1130 (Compiled f  
12. rame)  
13.  - java.util.concurrent.ThreadPoolExecutor$Worker.run() @bci=5, line=615 (Interpreted frame)  
14.  - java.lang.Thread.run() @bci=11, line=744 (Interpreted frame)  
15.   
16.   
17. Thread 31971: (state = BLOCKED)  
18.  - sun.misc.Unsafe.park(boolean, long) @bci=0 (Compiled frame; information may be imprecise)  
19.  - java.util.concurrent.locks.LockSupport.parkNanos(java.lang.Object, long) @bci=20, line=226 (Compiled frame)  

有锁的例子-------->
代码：

Java代码 

1. class T1 extends Thread {  
2.     private Object lockA;  
3.     private Object lockB;  
4.       
5.     public T1(Object lockA,Object lockB){  
6.         this.lockA = lockA;  
7.         this.lockB = lockB;  
8.     }  
9.       
10.     @Override  
11.     public void run() {  
12.         System.out.println("T1 runing begin");  
13.         synchronized (lockA) {  
14.             try {  
15.                 Thread.sleep(1000);  
16.             } catch (InterruptedException e) {  
17.             }  
18.               
19.             synchronized (lockB) {  
20.                 System.out.println("T1 runing over");  
21.             }  
22.         }  
23.     }  
24. }  
25.   
26.   
27.   
28.   
29. class T2 extends Thread {  
30.     private Object lockA;  
31.     private Object lockB;  
32.       
33.     public T2(Object lockA,Object lockB){  
34.         this.lockA = lockA;  
35.         this.lockB = lockB;  
36.     }  
37.       
38.     @Override  
39.     public void run() {  
40.         System.out.println("T2 runing begin");  
41.         synchronized (lockB) {  
42.             try {  
43.                 Thread.sleep(1000);  
44.             } catch (InterruptedException e) {  
45.             }  
46.               
47.             synchronized (lockA) {  
48.                 System.out.println("T2 runing over");  
49.             }  
50.         }  
51.     }  
52. }  
53.   
54. /** 
55.  * @author xinchun.wang 
56.  */  
57. public class LockTest {  
58.   
59.     public static void main(String[] args) {  
60.         Object lockA = new Object();  
61.         Object lockB = new Object();  
62.         T1 t1 = new T1(lockA,lockB);  
63.           
64.           
65.         T2 t2 = new T2(lockA,lockB);  
66.         t1.start();  
67.         t2.start();  
68.   
69.     }  
70. }  

输出：
T1 runing begin
T2 runing begin

Java代码 

1. C:\Windows\System32>jstack  22144  
2. 2016-08-09 20:00:10  
3. Full thread dump Java HotSpot(TM) 64-Bit Server VM (20.14-b01 mixed mode):  
4.   
5. "DestroyJavaVM" prio=6 tid=0x00000000008ac000 nid=0xd134 waiting on condition [0x0000000000000000]  
6.    java.lang.Thread.State: RUNNABLE  
7.   
8. "Thread-1" prio=6 tid=0x00000000068c7000 nid=0x6d0c waiting for monitor entry [0x000000000733f000]  
9.    java.lang.Thread.State: BLOCKED (on object monitor)  
10.         at com.springapp.mvc.com.springapp.mvc.T2.run(LockTest.java:50)  
11.         - waiting to lock <0x00000007d5fa25e8> (a java.lang.Object)  
12.         - locked <0x00000007d5fa25f8> (a java.lang.Object)  
13.   
14. "Thread-0" prio=6 tid=0x00000000068c4800 nid=0xbf28 waiting for monitor entry [0x000000000723f000]  
15.    java.lang.Thread.State: BLOCKED (on object monitor)  
16.         at com.springapp.mvc.com.springapp.mvc.T1.run(LockTest.java:22)  
17.         - waiting to lock <0x00000007d5fa25f8> (a java.lang.Object)  
18.         - locked <0x00000007d5fa25e8> (a java.lang.Object)  
19.   
20. "Low Memory Detector" daemon prio=6 tid=0x00000000068b0800 nid=0xd270 runnable [0x0000000000000000]  
21.    java.lang.Thread.State: RUNNABLE  
22.   
23. "C2 CompilerThread1" daemon prio=10 tid=0x00000000068a3800 nid=0xbe48 waiting on condition [0x0000000000000000]  
24.    java.lang.Thread.State: RUNNABLE  
25.   
26. "C2 CompilerThread0" daemon prio=10 tid=0x0000000006859800 nid=0xd2e4 waiting on condition [0x0000000000000000]  
27.    java.lang.Thread.State: RUNNABLE  
28.   
29. "Attach Listener" daemon prio=10 tid=0x0000000006858800 nid=0xb5fc waiting on condition [0x0000000000000000]  
30.    java.lang.Thread.State: RUNNABLE  
31.   
32. "Signal Dispatcher" daemon prio=10 tid=0x0000000006853800 nid=0xc62c runnable [0x0000000000000000]  
33.    java.lang.Thread.State: RUNNABLE  
34.   
35. "Finalizer" daemon prio=8 tid=0x0000000006845800 nid=0xcd4c in Object.wait() [0x0000000006b3f000]  
36.    java.lang.Thread.State: WAITING (on object monitor)  
37.         at java.lang.Object.wait(Native Method)  
38.         - waiting on <0x00000007d5f61300> (a java.lang.ref.ReferenceQueue$Lock)  
39.         at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:118)  
40.         - locked <0x00000007d5f61300> (a java.lang.ref.ReferenceQueue$Lock)  
41.         at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:134)  
42.         at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:159)  
43.   
44. "Reference Handler" daemon prio=10 tid=0x0000000000828000 nid=0x92d0 in Object.wait() [0x000000000683f000]  
45.    java.lang.Thread.State: WAITING (on object monitor)  
46.         at java.lang.Object.wait(Native Method)  
47.         - waiting on <0x00000007d5f611d8> (a java.lang.ref.Reference$Lock)  
48.         at java.lang.Object.wait(Object.java:485)  
49.         at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:116)  
50.         - locked <0x00000007d5f611d8> (a java.lang.ref.Reference$Lock)  
51.   
52. "VM Thread" prio=10 tid=0x0000000000822000 nid=0x7e60 runnable  
53.   
54. "GC task thread#0 (ParallelGC)" prio=6 tid=0x0000000000778000 nid=0xce94 runnable  
55.   
56. "GC task thread#1 (ParallelGC)" prio=6 tid=0x0000000000779800 nid=0xc574 runnable  
57.   
58. "GC task thread#2 (ParallelGC)" prio=6 tid=0x000000000077c000 nid=0x7f18 runnable  
59.   
60. "GC task thread#3 (ParallelGC)" prio=6 tid=0x000000000077d800 nid=0x7f1c runnable  
61.   
62. "VM Periodic Task Thread" prio=10 tid=0x00000000068b9800 nid=0xc3dc waiting on condition  
63.   
64. JNI global references: 882  
65.   
66.   
67. Found one Java-level deadlock:  
68. =============================  
69. "Thread-1":  
70.   waiting to lock monitor 0x0000000006842b30 (object 0x00000007d5fa25e8, a java.lang.Object),  
71.   which is held by "Thread-0"  
72. "Thread-0":  
73.   waiting to lock monitor 0x00000000068453e0 (object 0x00000007d5fa25f8, a java.lang.Object),  
74.   which is held by "Thread-1"  
75.   
76. Java stack information for the threads listed above:  
77. ===================================================  
78. "Thread-1":  
79.         at com.springapp.mvc.com.springapp.mvc.T2.run(LockTest.java:50)  
80.         - waiting to lock <0x00000007d5fa25e8> (a java.lang.Object)  
81.         - locked <0x00000007d5fa25f8> (a java.lang.Object)  
82. "Thread-0":  
83.         at com.springapp.mvc.com.springapp.mvc.T1.run(LockTest.java:22)  
84.         - waiting to lock <0x00000007d5fa25f8> (a java.lang.Object)  
85.         - locked <0x00000007d5fa25e8> (a java.lang.Object)  
86.   
87. Found 1 deadlock.  

线程状态的分析：
Runnable：该状态表示线程具备所有运行条件，在运行队列中准备操作系统的调度，或者正在运行。

Wait on condition ：
该状态出现在线程等待某个条件的发生。具体是什么原因，可以结合 stacktrace来分析。最常见的情况是线程在等待网络的读写，比如当网络数据没有准备好读时，线程处于这种等待状态，而一旦有数据准备好读之后，线程会重新激活，读取并处理数据。在 Java引入 NewIO之前，对于每个网络连接，都有一个对应的线程来处理网络的读写操作，即使没有可读写的数据，线程仍然阻塞在读写操作上，这样有可能造成资源浪费，而且给操作系统的线程调度也带来压力。在 NewIO里采用了新的机制，编写的服务器程序的性能和可扩展性都得到提高。
        如果发现有大量的线程都在处在 Wait on condition，从线程 stack看， 正等待网络读写，这可能是一个网络瓶颈的征兆。因为网络阻塞导致线程无法执行。一种情况是网络非常忙，几 乎消耗了所有的带宽，仍然有大量数据等待网络读 写；另一种情况也可能是网络空闲，但由于路由等问题，导致包无法正常的到达。所以要结合系统的一些性能观察工具来综合分析，比如 netstat统计单位时间的发送包的数目，如果很明显超过了所在网络带宽的限制 ; 观察 cpu的利用率，如果系统态的 CPU时间，相对于用户态的 CPU时间比例较高；如果程序运行在 Solaris 10平台上，可以用 dtrace工具看系统调用的情况，如果观察到 read/write的系统调用的次数或者运行时间遥遥领先；这些都指向由于网络带宽所限导致的网络瓶颈。另外一种出现 Wait on condition的常见情况是该线程在 sleep，等待 sleep的时间到了时候，将被唤醒。

BLOCKED： 线程sleep 就会进入这个
锁的分析：
Found 1 deadlock.
其中：
Thread-1 持有0x00000007d5fa25f8 锁，希望获取0x00000007d5fa25e8
Thread-2 持有0x00000007d5fa25e8锁，希望获取0x00000007d5fa25f8

而
"Thread-0":
  waiting to lock monitor 0x00000000068453e0 (object 0x00000007d5fa25f8, a java.lang.Object),
  which is held by "Thread-1"
也会提醒：Thread-0 需要获取的0x00000007d5fa25f8 是由 Thread-1 持有。

其他：

  TIME列就是各个Java线程耗费的CPU时间，CPU时间最长的是线程ID为21742的线程，用

printf "%x\n" 21742

    得到21742的十六进制值为54ee，下面会用到。    

    OK，下一步终于轮到jstack上场了，它用来输出进程21711的堆栈信息，然后根据线程ID的十六进制值grep