线程的状态

Java中线程的状态是通过枚举类型Thread.State表示的 ，通过打印这些枚举类型，就可以知道java中线程的状态有哪些

public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
       }
   }
}
1
2
3
4
5
6
7

线程实例通过getState()方法可以知道当前线程所处的状态

NEW状态

public class Demo14 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            System.out.println("hello thread");
        });
        //通过这个方法获取指定线程的状态，t调用的就获取t的状态
        System.out.println(t.getState());
        t.start();
    }
}
1
2
3
4
5
6
7
8
9
10

线程对象在调用start()方法之前调用getState()方法，此时的状态就是NEW状态。
对象创建好了，但是系统里面还没有对应的线程，也就相当于任务分配了，但是还没去执行

TERMINATED状态

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            System.out.println("hello thread");
        });
        t.start();
		Thread.sleep(1000);
        System.out.println(t.getState());
    }
}
1
2
3
4
5
6
7
8
9
10

操作系统中的线程已经执行完毕，销毁了，但是Thread对象还在，此时就是TERMINATED状态

NEW状态和TERMINATED状态是Java内部定义的状态，和操作系统中的线程的PCB(线程状态在PCB中存放)没啥关系

RUNNABLE状态

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true){}
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState());
    }
}
1
2
3
4
5
6
7
8
9
10

处于这个状态的线程，PCB就会被放到就绪队列中，随时都可以被CPU调度。如果代码中没有进行sleep，也没有进行其他的导致阻塞的操作，代码大概率就是处在RUNNABLE状态

TIMED_ WAITING状态(阻塞状态之一)

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

代码中调用了sleep，join(超时时间)，就会进入该状态，表示当前线程在一定时间内，是阻塞状态，一定时间之后，阻塞状态解除

BLOCKED状态(阻塞状态之一)

public class Demo14 {
    private static Object object = new Object();
    public static void main(String[] args) throws InterruptedException {
        synchronized (object){
            Thread t = new Thread(()->{
                synchronized (object) {
                    System.out.println("hello,thread");
                }
            });

            t.start();
            Thread.sleep(1000);
            System.out.println(t.getState());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

当线程正在等待锁时，就会处于BLOCKED状态

WAITING状态(阻塞状态之一)

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread t = new Thread(()->{
            synchronized (object){
                System.out.println("synchronized之前");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("synchronized之后");
            }
        });

        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState());
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

当线程正在等待其他线程唤醒，就会处在WAITING状态

为什么要将阻塞状态分得这么细？

这是非常有好处的！因为在开发过程中经常会遇到程序"卡死"的情况，"卡死"就是一些关键的线程阻塞了，在分析"卡死"原因的时候，第一步就可以先看看当前程序中的各个关键线程所处的状态，通过分析线程所处的状态就能知道程序"开始"的原因

线程状态转换图