场景需求

有些时候我们需要查看下jvm中的线程执行情况，比如，发现服务器的CPU的负载突然增高了、出现了死锁、死循环等，我们该如何分析呢？由于程序是正常运行的，没有任何的输出，从日志方面也看不出什么问题，所以就需要看下jvm的内部线程的执行情况，然后再进行分析查找出原因。

这个时候，就需要借助于jstack命令了，jstack的作用是将正在运行的jvm的线程情况进行快照，并且打印出来：

#用法：jstack <pid>

jstack 2203

线程状态

在Java中线程的状态一共被分成6种：

• 初始态（NEW）

  • 创建一个Thread对象，但还未调用start()启动线程时，线程处于初始态。

• 运行态（RUNNABLE），在Java中，运行态包括 就绪态 和 运行态。

  • 就绪态

    • 该状态下的线程已经获得执行所需的所有资源，只要CPU分配执行权就能运行。
    • 所有就绪态的线程存放在就绪队列中。

  • 运行态

    • 获得CPU执行权，正在执行的线程。
    • 由于一个CPU同一时刻只能执行一条线程，因此每个CPU每个时刻只有一条运行态的线程。

• 阻塞态（BLOCKED）

  • 当一条正在执行的线程请求某一资源失败时，就会进入阻塞态。
  • 而在Java中，阻塞态专指请求锁失败时进入的状态。
  • 由一个阻塞队列存放所有阻塞态的线程。
  • 处于阻塞态的线程会不断请求资源，一旦请求成功，就会进入就绪队列，等待执行。

• 等待态（WAITING）

  • 当前线程中调用wait、join、park函数时，当前线程就会进入等待态。
  • 也有一个等待队列存放所有等待态的线程。
  • 线程处于等待态表示它需要等待其他线程的指示才能继续运行。
  • 进入等待态的线程会释放CPU执行权，并释放资源（如：锁）

• 超时等待态（TIMED_WAITING）

  • 当运行中的线程调用sleep(time)、wait、join、parkNanos、parkUntil时，就会进入该状态；
  • 它和等待态一样，并不是因为请求不到资源，而是主动进入，并且进入后需要其他线程唤醒；
  • 进入该状态后释放CPU执行权 和 占有的资源。
  • 与等待态的区别：到了超时时间后自动进入阻塞队列，开始竞争锁。

• 终止态（TERMINATED）

  • 线程执行结束后的状态。

实战：死锁问题

如果在生产环境发生了死锁，我们将看到的是部署的程序没有任何反应了，这个时候我们可以借助jstack进行分析，下面我们实战下查找死锁的原因。

构造死锁：

编写代码，启动2个线程，Thread1拿到了obj1锁，准备去拿obj2锁时，obj2已经被Thread2锁定，所以发送了死锁。

public class TestDeadLock {

    private static final Object obj1 = new Object();
    private static final Object obj2 = new Object();

    public static void main(String[] args) {
        new Thread(new Thread1()).start();
        new Thread(new Thread2()).start();
    }

    private static class Thread1 implements Runnable{

        @Override
        public void run() {
            synchronized (obj1){
                System.out.println("Thread1 拿到了 obj1 的锁！ ");
                try {
                    // 停顿2秒的意义在于：让Thread2线程拿到obj2的锁。
                    Thread.sleep(2000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                synchronized (obj2){
                    System.out.println("Thread1 拿到了 obj2 的锁 ！");
                }
            }
        }
    }

    private static class Thread2 implements Runnable{

        @Override
        public void run() {
            synchronized (obj2){
                System.out.println("Thread2 拿到了 obj2 的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj1){
                    System.out.println("Thread2 拿到了 obj1 的锁");
                }
            }
        }
    }

}

使用jstack进行分析

jstack 3256

在输出的信息中，已经看到，发现了1个死锁，关键信息如下：

"Thread-1": at TestDeadLock$Thread2.run(TestDeadLock.java:47) - waiting to lock <0x00000000f655dc40> (a java.lang.Object) - locked <0x00000000f655dc50> (a java.lang.Object) at java.lang.Thread.run(Thread.java:748) 
"Thread-0": at TestDeadLock$Thread1.run(TestDeadLock.java:27) - waiting to lock <0x00000000f655dc50> (a java.lang.Object) - locked <0x00000000f655dc40> (a java.lang.Object) at java.lang.Thread.run(Thread.java:748)

可以清晰的看到：

Thread2 获取了 <0x00000000f655dc50> 的锁，等待获取 <0x00000000f655dc40> 这个锁

Thread1 获取了 <0x00000000f655dc40> 的锁，等待获取 <0x00000000f655dc50> 这个锁

由此可见，发生了死锁。