JavaEE之多线程编程：3. 线程的状态（易懂！）

文章目录

• • 一、关于线程的状态
  • 二、观察线程的所有状态
  • • 1. NEW状态
    • 2. TERMINATED状态
    • 3. RUNNABLE状态
    • 4. TIMED_WAITING

      一、关于线程的状态

      进程最核心的状态，一个是就绪状态，一个是阻塞状态（对于线程同样使用）。

      以线程为单位进行调度的。

      在Java中，又给线程赋予了一些其他的状态。

      线程的状态是一个枚举类型 Thread.State

      public class ThreadState {
          public static void main(String[] args) {
              for (Thread.State state : Thread.State.values()) { //遍历枚举中的每个元素
                  System.out.println(state);
             }
         }
      }
      

      二、观察线程的所有状态

      线程的状态一共有6个：

      • NEW：安排了工作, 还未开始行动。（Thread对象已经有了，.start()方法还没调用）
      • TERMINATED：工作完成了。（Thread对象还在，内核中的线程已经没了）
      • RUNNABLE：可工作的，又可以分成正在工作中和即将开始工作。（就绪状态 线程已经在cpu上执行了/线程正在排队等待上cpu执行）
      • TIMED_WAITING：表示排队等待其他事情（阻塞，由于sleep这种固定的方式产生的阻塞）
      • WAITING：表示排队等待其他事情（阻塞，由于wait这种不固定时间的方式产生的阻塞）
      • BLOCKED：表示排队等待其他事情（阻塞，由于锁竞争导致的阻塞）

        后三个都是阻塞状态，是把三种不同的阻塞状态的原因给拎出来了。这样后续定位“线程卡死”问题的时候，就很容易通过状态来初步确定卡死的原因是什么了。

        1. NEW状态

        并没有调用start() 也并没有调用线程，此时它对象里面的状态就是new状态（开始状态）。

         public static void main(String[] args) {
                Thread t = new Thread(() -> {
                    while (true) {
                    }
                });
                //在调用 start 之前获取状态，此时就是NEW状态
                System.out.println(t.getState()); //并没有调用start() 也并没有调用线程，此时它对象里面的状态就是new状态
                
        //运行结果：NEW 
        

        2. TERMINATED状态

        在线程执行结束之后，获取线程状态，此时是TERMINARED状态（结束状态）。

          public static void main(String[] args) throws InterruptedException {
                Thread t = new Thread(() -> {
                 
                });
                t.start();
                t.join(); //通过join方法进行等待
                //在线程执行结束之后，获取线程的状态，此时是TERMINARED状态
                System.out.println(t.getState());
         //执行结果：TERMINARED       
        

        3. RUNNABLE状态

        表示此线程正在运行当中，或者它随时准备去运行，此时它就是就绪状态。

        public static void main(String[] args) throws InterruptedException {
                Thread t = new Thread(() -> {
                    while (true) { //此线程全速运行
                    }
                });
                
                t.start();
                for (int i = 0; i < 5; i++) {
                    System.out.println(t.getState());
                    Thread.sleep(1000); //主线程中，每隔1秒钟打印一次
                }
            }
        //运行结果：
        RUNNABLE
        RUNNABLE
        RUNNABLE
        RUNNABLE
        RUNNABLE
        //且RUNNABLE每1s中运行一次
        

        4. TIMED_WAITING

        表示指定一定时间来进行等待。

         public static void main(String[] args) throws InterruptedException {
                Thread t = new Thread(() -> {
                    while (true) {
                        try {
                            Thread.sleep(1000); //等待1s
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
                t.start();
                for (int i = 0; i < 5; i++) {
                    System.out.println(t.getState());
                    Thread.sleep(1000);
                }
            }
        }
        //输出结果：
        RUNNABLE
        TIMED_WAITING
        TIMED_WAITING
        TIMED_WAITING
        TIMED_WAITING
        //设置了等待1s再执行，所以第1s没有执行到，打印主线程的代码
        

        上述内容，是多进程中的四种状态。