Java 线程的几种状态

一、 线程的状态

  状态是针对当前的线程调度的情况来描述的。因为线程是调度的基本单位，所以状态更应该是线程的属性。在Java中线程的状态一共有六种：

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
3. 阻塞(BLOCKED)：表示线程阻塞于锁。
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
6. 终止(TERMINATED)：表示该线程已经执行完毕。

二、状态间相互转换

 NEW（线程对象刚创建，PCB 还未创建）调用了 start 真正的创建了线程，此时状态变为RUNNABLE（线程可以随时参加调度），线程执行完 run 方法以后，PCB被释放，但是线程对象还在，此时状态为 TERMINATED。三个阻塞等待都是由RUNNABLE切换而来。具体联系如下图所示：

三、状态详细说明

3.1  初始状态(NEW)

实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

public class demo {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            
        });
        System.out.println(t1.getState());
    }
}

3.2 运行状态(Runnable) 

Runnable 包括了操作系统线程中的 Running（运行中）和 Ready（就绪）
线程对象创建后，其他线程(比如 main 线程）调用了该对象的 start()方法，该状态的线程位于可运行线程池中，等待被线程调度选中，获取 CPU 的使用权，也就是说有了被 CPU 运行的资格Running（运行中） 就绪状态的线程在获得 CPU 时间片后转换为运行中（Running）

public class demo {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            
        });
        t1.start();
        System.out.println(t1.getState());
    }
}

3.3 等待状态（Waiting）

这种状态的线程不会被分配 CPU 执行时间，不给过无需等待被他其他线程显示地唤醒，在一定时间之后他们会被系统自动唤醒

public class demo {
     public static void main(String[] args) throws InterruptedException {
         Object ob = new Object();
         Thread t1 = new Thread(()->{
             synchronized (ob){
                 try {
                     ob.wait();
                 } catch (InterruptedException e) {
                     throw new RuntimeException(e);
                 }
             }
        });
         t1.start();
         Thread.sleep(1000);//这里sleep是为了避免主函数运行过快,显示Runnable
         System.out.println(t1.getState());
    }
}

3.4 阻塞状态（Blocked）

个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入输出操作时，将让出CPU并暂时中止自己的执行，进入堵塞状态。

在可执行状态下，如果调用sleep()、suspend()、wait()等方法，线程都将进入阻塞状态。阻塞时，线程不能进入排队队列，只能当引起阻塞的原因被消除后，线程转入就绪状态，重新到就绪队列中排队等待，这时被CPU调度选中后会从原来停止的位置开始继续执行。

记住：阻塞被消除后是回到就绪状态，不是运行状态。

public class demo {
    synchronized public static void func() {
        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
     public static void main(String[] args) throws InterruptedException {
         Thread t1 = new Thread(()->{
             func();
         });
 
         Thread t2 = new Thread(()->{
             func();
         });
//t2先获得锁,t1只能阻塞等待
         t2.start();
         t1.start();
         System.out.println(t2.getState());
         System.out.println(t1.getState());
    }
}

 3.5 .超时等待状态（Timed Waiting）

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

public class demo {
    public static void main(String[] args) throws InterruptedException {
        Object ob = new Object();
        Thread t1 = new Thread(()->{
            synchronized (ob){
                try {
                    ob.wait(10000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        Thread.sleep(1000);//这里sleep是为了避免主函数运行过快,显示Runnable
        System.out.println(t1.getState());
    }
}

3.6 终止状态（Terminated）

• 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。

• 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常

public class demo {
    public static void main(String[] args) throws InterruptedException {
        Object ob = new Object();
        Thread t1 = new Thread(()->{
        });
        t1.start();
        Thread.sleep(1000);//这里sleep是为了让线程运行完毕,避免主函数运行过快显示Runnable
        System.out.println(t1.getState());
    }
}

四、 拓展：

问：线程状态 RUNNABLE 如何变为 BLOCKED? 
答：线程状态变为阻塞有多种原因：可能调用 wait () 方法进入等待池，可能执行同
步方法 / 同步代码块进入等锁池，可能调用了 sleep ()/join () 等待休眠或其他
线程结束，可能发生了 I/O 中断等。

问： 什么是线程池？ 为什么要使用它？

答：创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。从 JDK1.5 开始，Java API 提供了 Executor 框架让你可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短的任务的程序的可扩展线程池）。

问：什么是死锁？如何避免死锁？

答：死锁是指多个线程相互等待对方释放资源而无法继续执行的情况。要避免死锁，可以采用避免策略，比如按照固定的顺序获取锁，或者设置超时时间来放弃获取锁。