JavaEE——线程的状态

目录

• 前言
• [1. NEW](#1. NEW)
• [2. TERMINATED](#2. TERMINATED)
• [3. RUNNABLE](#3. RUNNABLE)
• [4. 三种阻塞状态](#4. 三种阻塞状态)
• 总结

前言

本篇文章来讲解线程的几种状态。在Java中，线程的状态是一个枚举类型，Thread.State。其中一共分为了六个状态。分别为：NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,

TERMINATED

1. NEW

new：安排了⼯作, 还未开始⾏动

new状态表示Thread对象已经创建，但是并没有执行Start()语句

public class Demo13 {
    public static void main(String[] args) {
        //观看线程的NEW状态
        Thread t = new Thread(() -> {

        });
        System.out.println(t.getState());
        t.start();
    }
}

2. TERMINATED

terminated：⼯作完成了.

就是表示线程结束的状态

public class Demo13 {
    public static void main(String[] args) throws InterruptedException {
        //观看线程的NEW状态
        Thread t = new Thread(() -> {

        });
        System.out.println(t.getState());
        t.start();
        t.join();
        System.out.println(t.getState());
    }
}

3. RUNNABLE

runnable:可⼯作的. ⼜可以分成正在⼯作中和即将开始⼯作.

runnable即就绪状态

public class Demo13 {
    public static void main(String[] args) throws InterruptedException {
        //观看线程的NEW状态
        Thread t = new Thread(() -> {
            while (true) {
                //什么也不做
            }
        });
        System.out.println(t.getState());
        t.start();

        System.out.println(t.getState());
        
        t.join();
        System.out.println(t.getState());
    }
}

由于内部是while死循环，main一直在等待t线程，故不会结束。

4. 三种阻塞状态

BLOCKED，WAITING，TIMED_WAITING 都表示排队等着其他事情，也就是都表示阻塞状态。但是还是有区别的，BLOCKED表示由于加锁产生的阻塞，WAITING表示无超时时间的阻塞，TIMED_WAITING表示有超时时间的阻塞。也就是说使用join()进行等待就是WAITING，使用join(time)或者使用sleep()进行等待就是 TIMED_WAITING。

下面观察WAITING和TIMED_WAITING状态。

使用一个监视器线程来观察main的状态

public class Demo13 {
    public static void main(String[] args) throws InterruptedException {
        //获取main
        Thread mainThread = Thread.currentThread();
        //观看线程的NEW状态
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println(t.getState());
        t.start();

        System.out.println(t.getState());

        //观察使用一个监视器线程来观察main线程的状态
        Thread monitor = new Thread(()-> {
            try {
                Thread.sleep(1000);
                System.out.println(mainThread.getState());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("main等待前的状态：" + mainThread.getState());

        monitor.start();
        System.out.println("main线程开始等待");
        t.join();

        System.out.println(t.getState());
    }

观察TIMED_WAITING状态只需将最下面的join加入参数：

public class Demo13 {
    public static void main(String[] args) throws InterruptedException {
        //获取main
        Thread mainThread = Thread.currentThread();
        //观看线程的NEW状态
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println(t.getState());
        t.start();

        System.out.println(t.getState());

        //观察使用一个监视器线程来观察main线程的状态
        Thread monitor = new Thread(()-> {
            try {
                Thread.sleep(1000);
                System.out.println(mainThread.getState());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("main等待前的状态：" + mainThread.getState());

        monitor.start();
        System.out.println("main线程开始等待");
        t.join(5000);

        System.out.println(t.getState());
    }
}

BLOCKED状态需要对线程进行加锁，加锁操作将在后面的文章中讲到，故在此处不演示BLOCKED状态。

总结

本文章介绍了java线程中的六个状态，在实际工作中调试中就可能需要打印线程状态，来查找程序中的错误。