【工作随手记】deaklock排查

生产环境当中还没真正遇到过死锁的问题。有些疑似死锁的问题，后来经过排查也只是其它问题导致的。所以通过jstack到底怎样排查死锁问题有点疏忽了。这里作个记录。

模拟一个死锁

顺便复习一下。

死锁的产生有四个必要的条件

互斥使用，即当资源被一个线程占用时，别的线程不能使用

不可抢占，资源请求者不能强制从资源占有者手中抢夺资源，资源只能由占有者主动释放

请求和保持，当资源请求者在请求其他资源的同时保持对原因资源的占有

循环等待，多个线程存在环路的锁依赖关系而永远等待下去，例如T1占有T2的资源，T2占有T3的资源，T3占有T1的资源，这种情况可能会形成一个等待环路

对于死锁产生的四个条件只要能破坏其中一条即可让死锁消失，但是条件一是基础，不能被破坏。

模拟一个死锁。

 private static String lock1 = "lock1";

    private static String lock2 = "lock2";

    public static void main(String[] args) {

        Runnable r1 = new Runnable() {

            @Override

            public void run() {

                synchronized (lock1){

                    try {

                        Thread.sleep(3000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println(Thread.currentThread() + " 锁住了lock1");

                    synchronized (lock2){

                        System.out.println(Thread.currentThread() + " 锁住了lock2");

                    }

                }

            }

        };

        Runnable r2 = new Runnable() {

            @Override

            public void run() {

                synchronized (lock2){

                    try {

                        Thread.sleep(5000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println(Thread.currentThread() + " 锁住了lock2");

                    synchronized (lock1){

                        System.out.println(Thread.currentThread() + " 锁住了lock1");

                    }

                }

            }

        };

        ExecutorService executorService = Executors.newFixedThreadPool(5);

        executorService.submit(r1);

        executorService.submit(r2);

    }

执行输出

Thread[pool-1-thread-1,5,main] 锁住了lock1

Thread[pool-1-thread-2,5,main] 锁住了lock2

后面一直卡住，通过idea查看堆栈信息可以看到，两个线程互相一直在等待对方释放锁。

"pool-1-thread-2" #13 prio=5 os_prio=0 tid=0x000000001ebc6000 nid=0xcf950 waiting for monitor entry [0x00000000207fe000]

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

at com.nyp.test.DeadlockTest$2.run(DeadlockTest.java:49)

waiting to lock <0x000000076b19de70> (a java.lang.String)

locked <0x000000076b19dea8> (a java.lang.String)

at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)

at java.util.concurrent.FutureTask.run(FutureTask.java:266)

at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)

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

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

"pool-1-thread-1" #12 prio=5 os_prio=0 tid=0x000000001ebc5000 nid=0xcfa20 waiting for monitor entry [0x00000000206ff000]

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

at com.nyp.test.DeadlockTest$1.run(DeadlockTest.java:31)

waiting to lock <0x000000076b19dea8> (a java.lang.String)

locked <0x000000076b19de70> (a java.lang.String)

at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)

at java.util.concurrent.FutureTask.run(FutureTask.java:266)

at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)

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

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

通过idea我们很方便的观察到了两个线程在等待对方释放锁，而且通过观察其它的堆栈信息我们也能方便的知道，两个线程也分别锁住了对方想要申请的锁，因此造成了死锁。

但是在生产环境中，通过jstack会打印出一大堆线程的信息，而且只有有并发环境必然会上锁，堆栈信息当中必然会出现waiting for monitor``waiting on condition``locked等信息，这并不是死锁的完全充要条件。

将代码放到生产环境。通过jstack pid命令，可以看到会出现明确的deadlock的信息。

Found one Java-level deadlock:

"pool-4-thread-2":

waiting to lock monitor 0x00007f0c24026408 (object 0x00000005d0e7a708, a java.lang.String),

which is held by "pool-4-thread-1"

"pool-4-thread-1":

waiting to lock monitor 0x00007f0c24025c78 (object 0x00000005d0e7a740, a java.lang.String),

which is held by "pool-4-thread-2"

Java stack information for the threads listed above:

"pool-4-thread-2":

at com.alpha.data.util.DeadlockTest$2.run(DeadlockTest.java:49)

waiting to lock <0x00000005d0e7a708> (a java.lang.String)

locked <0x00000005d0e7a740> (a java.lang.String)

at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)

at java.util.concurrent.FutureTask.run(FutureTask.java:266)

at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)

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

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

"pool-4-thread-1":

at com.alpha.data.util.DeadlockTest$1.run(DeadlockTest.java:31)

waiting to lock <0x00000005d0e7a740> (a java.lang.String)

locked <0x00000005d0e7a708> (a java.lang.String)

at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)

at java.util.concurrent.FutureTask.run(FutureTask.java:266)

at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)

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

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

Found 1 deadlock.

也就是在生产环境中，通过jstack排查死锁问题时，只需要盯着deadlock字样即可，如果有死锁会明显的提示出产生死锁的代码所在。否则，便是没有死锁。

顺便复习一下通过jstack排查cpu占用高的问题

1.通过top命令找到cpu占用高的应用程序进程

2.通过top -H -p pid查看该应用中占用CPU高的线程。

3.通过printf "%x\n" pid 将线程高的线程号转为十六进制。

4.通过jstack过滤该十六进制的关键信息。jstack pid | grep 十六进制 -c 10

这样就可以看到占用CPU高的代码位置。

总结：就是先查到占用高的应用和具体的线程，然后根据线程到堆积信息查找即可。

不过堆栈信息非十进制，需提前把线程号转为十六进制。