概览
Java语言中，多线程是由线程的核心概念驱动的，而线程的生命周期会经历以下的不同状态。
Java java.lang.Thread类包含了一个静态类State，它定义了线程的状态，在任意一个时间点上，线程只可能是其中的一个状态，我们接下来逐一讨论每个状态。
NEW
新创建且还未被执行的线程
在我们调用start()方法之前当前线程将一直保持该状态：
Runnable runnable = new NewState();
Thread t = new Thread(runnable);
log.info(t.getState());
由于我们还未调用start()方法，最后将打印
NEW
RUNNABLE
当前线程正在运行或处于就绪状态（等待CPU分配执行时间）
当我们调用start()方法之后，线程状态将由NEW状态切换到RUNABLE状态。
多线程环境下，线程调度器（属于JVM管辖）分配一定的时间给每个线程，当运行一定时间后将控制权交给其他可运行线程。
我们现在在上面的例子后面加上运行start()方法的代码再次获取一下当前的状态：
Runnable runnable = new NewState();
Thread t = new Thread(runnable);
t.start();
log.info(t.getState());
运行一下结果很有可能输出如下：
RUNNABLE
注意我们不能保证肯定会输出RUNNABLE状态，因为当我们调用t.getState()方法时，线程有可能执行完成了。
BLOCKED
等待获取到一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生，之后当前线程进入同步区域
我们来看个例子：
public class BlockedState {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new DemoThreadB());
Thread t2 = new Thread(new DemoThreadB());
t1.start();
t2.start();
Thread.sleep(1000);
log.info(t2.getState());
System.exit(0);
}
}
class DemoThreadB implements Runnable {
@Override
public void run() {
commonResource();
}
public static synchronized void commonResource() {
while(true) {
// 无限循环来模拟耗时操作
// t1线程不会退出当前方法，t2线程无法进入
}
}
}
这段代码中，线程t1运行后进入到commonResource()同步方法中，这个一个排他锁，所有其他想进入该方法的线程都会被阻塞直到当前线程退出该方法。这时候线程t2也运行了，也需要访问commonResource()同步方法，但是由于线程t1在该方法中无限循环没有退出，t2将会一直保持BLOCKED状态，最后程序会打印：
BLOCKED
WAITING
当前线程不会被分配CPU执行时间，需被其他线程显示的唤醒
根据Java文档上解释，只有以下方法会让线程进入无限期的等待状态：
- 没有设置timeout参数的Object.wait()方法
- 没有设置timeout参数的Thread.join()方法
- LockSupport.park()方法
可参考这篇文章认识wait()、notify() 、notifyAll()，下面例子先展示join()方法调用后线程进入WAITING状态：
public class WaitingState implements Runnable {
public static Thread t1;
public static void main(String[] args) {
t1 = new Thread(new WaitingState());
t1.start();
}
public void run() {
Thread t2 = new Thread(new DemoThreadWS());
t2.start();
try {
t2.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("Thread interrupted", e);
}
}
}
class DemoThreadWS implements Runnable {
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("Thread interrupted", e);
}
log.info(WaitingState.t1.getState());
}
}
这段代码中，我们运行主线程创建线程t1并运行t1，在t1中我们创建线程t2并运行t2，在t2运行时，我们在t1使用t2.join()等待t2运行结束，这会让t1进入WAITING状态直到t2结束，当t1在等待t2执行结束的时候，我们在t2方法中调用t1.getState()来查看t1的状态，程序输入如下：
WAITING
TIMED_WAITING
当前线程也不会被分配CPU执行时间，不过无需被其他线程显示的唤醒，在一定时间之后会被系统自动唤醒
根据Java文档上解释，有以下5种方法能让线程进入限期等待状态：
- Thread.sleep()方法
- 设置了timeout参数的Object.wait()方法
- 设置了timeout参数的Thread.join()方法
- LockSupport.parkNanos()方法
- LockSupport.parkUntil()方法
我们来看个例子：
public class TimedWaitingState {
public static void main(String[] args) throws InterruptedException {
DemoThread obj1 = new DemoThread();
Thread t1 = new Thread(obj1);
t1.start();
// 休眠一秒让线程调度器有足够的时间去运行线程t1
Thread.sleep(1000);
log.info(t1.getState());
}
}
class DemoThread implements Runnable {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
log.error("Thread interrupted", e);
}
}
}
例子很简单，程序输出如下：
TIMED_WAITING
TERMINATED
当前线程已运行结束，已终止状态
后面会另写一篇文章详细讨论停止线程的不同方式，当前看下面的简单例子：
public class TerminatedState implements Runnable {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new TerminatedState());
t1.start();
// 休眠1秒让线程t1有足够时间执行完毕
Thread.sleep(1000);
Log.info(t1.getState());
}
@Override
public void run() {
// 什么也不做
}
}
程序输出如下：
TERMINATED
除了查看线程状态，我们还可以调用isAlive()方法来查看线程是否还活跃：
Assert.assertFalse(t1.isAlive());
当前状态下它会返回false，简单来说，线程只在调用start()后且未结束前活跃。