1.线程状态（生命周期）一个线程在给定的时间点只能处于一种状态。
线程可以有如下6 种状态：
new (新创建）：未启动的线程；
runnable (可运行）：可运行的线程，需要等待操作系统资源；
blocked (被阻塞）：等待监视器锁而被阻塞的线程；
waiting (等待）：等待唤醒状态，无限期地等待另一个线程唤醒；
timed waiting (计时等待）：在指定的等待时间内等待另一个线程执行操作的线程；
terminated (被终止）：已退出的线程。
要确定一个线程的当前状态， 可调用getstate 方法
线程状态关系图
注意：虚线框（全大写英文）的状态为java线程状态。
2.操作线程状态2.1.新创建状态（new）就是实例化线程完成后，未启动线程的状态。
可通过三种方式创建线程
重写thread类run()方法
实现runnable接口
实现callable接口
一个简单的例子概括三种方式
public class demo { public static void main(string[] args) throws executionexception, interruptedexception { /** * 1.直接重写run() 或继承thread类再重写run() */ thread thread = new thread() { @override public void run() { system.out.println("thread"); } }; // 开启线程 thread.start(); /** * 2.lambda、内部类或线程类方式实现runnable接口，实现run()方法 * 再交给thread 类 */ thread runthread = new thread(() -> { system.out.println("runnable"); }); // 开启线程 runthread.start(); /** * 3.lambda、内部类或线程类方式实现callable接口，实现call()方法 * 再交给thread 类：futuretask本质也是runnable实现类 */ futuretask<string> futuretask = new futuretask<string>(() -> { system.out.println("callable"); return "callablethread"; }); thread callthread = new thread(futuretask); // 开启线程 callthread.start(); // 获取call()方法的返回值 string s = futuretask.get(); system.out.println("call()方法的返回值："+s); }}
不重写 run() 或 call() 方法直接实例化thread类创建的线程没有实际意义；
只有callable方式创建的线程可以获取线程的返回值。
2.2.可运行状态（runnable）该状态指的是线程实例化对象调用start()方法后进入的状态。线程处于可以运行状态，如果有处理器等资源，就可以执行程序。
该状态在操作系统层面包含两步：线程就绪和线程运行中，但在java线程状态中，这两步都统称为runnable（可运行）状态。
线程由就绪状态变为运行状态，重点就看你的线程有没有抢到cpu资源（cpu时间片），谁抢到就运行，没抢到就等。因为cpu时间片（执行时间）非常短，大概十几毫秒，所以线程切换的这个时间是非常短的，就绪状态变为运行状态的时间也非常短，在开发时几乎感觉不到这种状态的变化，所以在java中将两者看作是一个整体，重点关注线程可否运行并区别于其他状态即可，更进一步简化线程的开发。如果你的程序要运行很久（比如写个死循环），在一个cpu时间片内没有执行完成，那么你的线程就要抢下一次的cpu时间片，抢到了才可以继续执行程序，没抢到那就要继续抢，直到线程中的程序执行完成。
其实这个场景应该都见到过，例如多个线程执行同一个程序，都将日志打印到同一个文件时，就会出现不同线程的日志混在了一起的情况，不利于排查问题。解决这种问题常见的方法有：一是分线程打印日志到不同文件；二是将日志信息保存到字符串对象中，在程序的最后将日志信息一次性打印到文件。第二种方式就是利用cpu的一个时间片来完成日志信息的打印。
注意：程序只能对新建状态的线程调用start()方法，不要对处于非新建状态的线程调用start() 方法，这都会引发illegalthreadstateexception异常。
2.3.被阻塞状态（blocked）线程处于等待监视器锁而被阻塞的状态。有一个线程获取了锁未释放，其他线程也来获取，但发现获取不到锁也进入了被阻塞状态。
被阻塞状态只存在于多线程并发访问下，区别于后面两种因线程自己进入”等待“而导致的阻塞。
进入状态
进入synchronized 代码块/方法
未获取到锁
退出状态
获取到监视器锁
2.4.等待唤醒状态（waiting）整个流程是这样的：线程在某个对象的同步方法中先获取到对象锁；在执行wait方法时，该线程将释放对象锁，并且该线程被放入到这个对象的等待队列；等待另一个线程获取到同一个对象的锁，然后通过notify() 或 notifyall() 方法唤醒对象等待队列中的线程。
从整个流程可以知道
wait (),notify () 和 notifyall () 方法需要在线程获取到锁的情况下才可以继续执行，所以这三个方法都需要放在同步代码块/方法中执行，否则报异常：java.lang.illegalmonitorstateexception。
在同步代码块中，线程进入waiting 状态时，锁会被释放，不会导致该线程阻塞。反过来想下，如果锁没释放，那其他线程就没办法获取锁，也就没办法唤醒它。
进入状态
object.wait()
thread.join()
locksupport.park()
退出状态
object.notify()
object.notifyall()
locksupport.unpark()
2.5.计时等待状态（timed_waiting）一般是计时结束就会自动唤醒线程继续执行后面的程序，对于object.wait(long) 方法还可以主动通知唤醒。
注意：thread类下的sleep() 方法可以放在任意地方执行；而wait(long) 方法和wait() 方法一样，需要放在同步代码块/方法中执行，否则报异常：java.lang.illegalmonitorstateexception。
进入状态
thread.sleep(long)
object.wait(long)
thread.join(long)
locksupport.parknanos(long)
locksupport.parknanos(object blocker, long nanos)
locksupport.parkuntil(long)
locksupport.parkuntil(object blocker, long deadline)
注：blocker 参数为负责此线程驻留的同步对象。
退出状态
计时结束
locksupport.unpark(thread)
object.notify()
object.notifyall()
2.6.终止（terminated）线程执行结束
run()/call() 执行完成
stop()线程
错误或异常>>意外死亡
stop() 方法已弃用。
3.查看线程的6种状态通过一个简单的例子来查看线程出现的6种状态。
案例
public class demo3 { private static object object ="obj"; public static void main(string[] args) throws interruptedexception { thread thread0 = new thread(() -> { try { // 被阻塞状态（blocked） synchronized (object){ system.out.println("thread0 进入：等待唤醒状态（waiting）"); object.wait(); system.out.println("thread0 被解除完成：等待唤醒状态（waiting）"); } system.out.println("thread0 "+thread.currentthread().getstate()); } catch (interruptedexception e) { e.printstacktrace(); } }); // 新创建状态（new） system.out.println(thread0.getname()+"："+thread0.getstate()); thread thread1 = new thread(() -> { try { system.out.println("thread1 进入：计时等待状态（timed_waiting）"); thread.sleep(2); system.out.println("thread1 出来：计时等待状态（timed_waiting）"); } catch (interruptedexception e) { e.printstacktrace(); } // 被阻塞状态（blocked） synchronized (object){ system.out.println("thread1 解除：等待唤醒状态（waiting）"); object.notify(); system.out.println("thread1 解除完成：等待唤醒状态（waiting）"); } system.out.println("thread1 "+thread.currentthread().getstate()); }); // 新创建状态（new） system.out.println(thread1.getname()+"："+thread1.getstate()); printstate(thread0); printstate(thread1); // 可运行状态（runnable） thread0.start(); // 可运行状态（runnable） thread1.start(); } // 使用独立线程来打印线程状态 private static void printstate(thread thread) { new thread(()->{ while (true){ system.out.println(thread.getname()+"："+thread.getstate()); if (thread.getstate().equals(thread.state.terminated)){ system.out.println(thread.getname()+"："+thread.getstate()); break; } } }).start(); }}
执行结果：简化后的输出结果
thread-0：new
thread-1：new
thread-0：runnable
thread-1：runnable
thread0 进入：等待唤醒状态（waiting）
thread-1：blocked
thread1 进入：计时等待状态（timed_waiting）
thread-0：blocked
thread-0：waiting
……
thread-0：waiting
thread-1：blocked
thread-1：timed_waiting
……
thread-1：timed_waiting
thread-1：blocked
……
thread-1：blocked
thread-0：waiting
……
thread-0：waiting
thread1 出来：计时等待状态（timed_waiting）
thread-0：waiting
thread-1：blocked
thread1 解除：等待唤醒状态（waiting）
thread-1：blocked
thread-0：waiting
thread-0：blocked
thread1 解除完成：等待唤醒状态（waiting）
thread-1：blocked
thread1 runnable
thread-0：blocked
thread-1：terminated
thread0 被解除完成：等待唤醒状态（waiting）
thread-0：blocked
thread0 runnable
thread-0：terminated
最终的执行结果如图。
注意：因为案例中使用了独立线程来打印不同线程的状态，会出现状态打印稍微延迟的情况。
以上就是java线程的6种状态与生命周期是什么的详细内容。