Java线程状态一直是让工程师容易迷惑的知识点，我觉得原因有二：一是线程的概念较为抽象，其状态转换的条件和时间点不容易理解；二是线程状态和进程状态不是完全对应的，且线程的状态词汇容易让人误解。下面我们通过jstack结合代码来探究一下Java线程状态相关的关键知识点。

Java线程状态有哪些？

Java线程底层进程状态并不是完全对应的，它只是JVM暴露给开发者用于了解线程运行情况的状态数据，该状态数据不能用于业务场景的判断。从Thread.State代码中可以看到，Java提供了6种线程状态，如下：

其中比较重要的是RUNNABLE、BLOCKED、WAITING、TIMED_WAITING这几个状态，下面我们分别做简要介绍。

RUNNABLE状态

该状态下的线程处于正在执行的状态，或者可能正在等待来自操作系统(如处理器)的其他资源，对应到操作系统线程中的Running和Ready状态。

比如我们执行一段空代码或者计算代码，此时线程的状态即是RUNNABLE。一般来说，为了能在分析的时候看的更清晰，我们会给线程/线程池定义个名字。

newThread(()->{
while(true){
inti=0;
i++;
i--;
    }
},"busyThread").start();

JDK中自带jstack命令，可以查看线程栈的情况，命令：

jstack -l 进程ID

我们看到，线程状态还有BLOCKED、WAITTING这几种，那么是不是对于I/O阻塞就是这两种呢？我们可以用下面代码测试下：

newThread(()->{
ServerSocketserverSocket=null;
try {
serverSocket=newServerSocket(10086);
while (true) {
//等待接收System.out.println("等待接收...");
Socketsocket=serverSocket.accept();
                }
            } catch (IOExceptione) {
e.printStackTrace();
            } finally {
try {
if(serverSocket!=null){
serverSocket.close();
                    }
                } catch (IOExceptione) {
e.printStackTrace();
                }
            }
        },"socketWaitThread").start();

使用jstack查看，如下图：

会发现，此时仍然是RUNNABLE状态（但CPU占用几乎为0），而不是BLOCKED、WAITTING。

BLOCKED状态

根据前面的例子也可以看出，Blocked状态跟IO阻塞是不一样的。BLOCKED是指线程阻塞时的状态，即等待一个锁的状态。简单来说，大致有两种情况可以让线程处于这个状态。

1. 线程A想进入某个同步快，但是由于该同步锁被其他线程占用，所以自己只能等待该锁，此时线程A为BLOCKED状态。
2. 线程A已经获取该锁，进入同步块，但调用了wait方法后释放了该锁，然后其他线程内执行了同一把锁对象的notify或者notifyAll后，此时线程A为BLOCKED状态。

下面代码演示了第一种情况：

Orderobj=newOrder(12);
newThread(()->{
synchronized (obj){
System.out.println("get lock by busyThread");
//等待100秒CommonUtils.waitFor(100000);
            }
        },"busyThread").start();
newThread(()->{
synchronized (obj){
System.out.println("get lock by computeThread");
            }
        },"computeThread").start();

使用jstack可以看到：

busyThread里面执行了一个耗时的操作（100s），导致锁迟迟不释放，computeThread拿不到锁，一直在同步块（synchronized）外等待，此时它就是BLOCKED状态。另外可以清楚的看到，等待锁对象0x00000007ff7b7310，和前面busyThread中locked的是同一个。

WAITING

根据JavaDoc，这个状态的线程会等待另一个线程执行一个特别的操作。让线程处于这个状态，是因为调用了下面的几个方法之一：

没有timeout的Object.wait

没有timeout的Thread.join

LockSupport.park

调用Object.wait时，该状态的线程在等待另一个线程调用Object.notify()或者notifyAll。

调用Thread.join时，该状态的线程在等待一个指定的线程终止操作。

wait/notify

首先我们看看wait/notify这个组合，它主要用于线程间的协作。比如在生产者消费者模式里，当生产者生产的物品达到一定量，消费者消费速度跟不上，此时可能会让生产者wait一下，等消费速度跟上来之后，通过notify来通知生产者继续生产。

调用wait/notify的前提是已经获取对象锁（在synchronized代码块内），而且共用同个对象，下面简单演示下wait/notify的用法：

Orderorder=newOrder(12);
newThread(()->{
synchronized (order){
try {
System.out.println(Thread.currentThread().getName()+" 等待前...");
order.wait();
System.out.println(Thread.currentThread().getName()+" 等待后...");
                } catch (InterruptedExceptione) {
e.printStackTrace();
                }
            }
        },"waitThread").start();
newThread(()->{
synchronized (order){
System.out.println("通知准备...");
CommonUtils.waitFor(60000);
order.notifyAll();
System.out.println("通知完成...");
            }
        },"notifyThread").start();

启动后，用jstack -l打印，结果如下：

程序运行结束后，可以看到控制台打印：

大家会看到，waitThread在调用了wait方法后，在等待notifyThread的notify的过程中，是处于WAITTING状态。它等待的是0x00000007ff7b8878这个对象锁内的notify调用。后者调用后，前者会继续执行完成。

另外，大家可以看到notifyThread由于调用了Thread.sleep方法，它目前处于TIMED_WAITING状态，这个状态后续会再提到。

join

假如有两个线程A和B，A中调用了B的join方法，表示B线程先执行完，才会继续执行A接下来的代码。通过join源码可以看出，之所以能暂停等待其他线程执行，是因为内部也依赖了wait方法，如下图所示：

TIMED_WAITING

这个状态和WAITING很类似，但是它是一种限时的等待。根据JavaDoc可知，在线程中调用下列其中一个方法，可以成为TIME_WAITING状态：

Thread.sleep

有timeout参数的Object.wait

有timeout参数的Thread.join

LockSupport.parkNanos

LockSupport.parkUntil

Thread.sleep的效果在前面有一定展示，这里不再赘述。