核心四：线程的一生

4、核心四：线程的一生💟

在这里插入图片描述

4.1 New

已创建但还未启动的新线程。

我们new Thread之后，线程已经实现了一些准备工作。但没有运行run方法，因为没有使用start来开启线程。此时，线程处于New状态。

4.2 Runnable（可运行的+正在运行的）

一旦调用start方法，线程就会进入Runnable。

注意：

只能由New状态到Runnable状态，不可以由New状态到Waiting状态
如果一个线程正在运行，此时CPU将资源给收走了，这个时候线程任然处于Runnable。因为一旦重新获得资源，线程就能够运行。所以线程处于可运行状态

4.3 Blocked

当一个线程进入到被synchronized修饰的代码块的时候，并且该锁已经被其他线程拿走了，我们无法获得锁。线程的状态就是Blocked

注意：一定要是synchronized修饰的方法或代码块

4.4 Waiting

4.5 Timed Waiting(计时等待)

该状态和Waiting状态非常类似。只不过一个是有时间期限的，另一个没有

注意：Blocked是等待另外一个线程释放排它锁monitor的到来。Waiting和Timed Waiting则是等待被唤醒或等待设置时间到来

4.6 Terminated(已终止)

run方法正常执行完毕
出现没有被捕获的异常，终止了run

/**
 * 显示现成的New、Runnable和Terminated
 * 即使是正在运行，也是Runnable状态，没有Running
 */
public class NewRunnableTerminated implements Runnable{
    public static void main (String[] args) {
        Thread thread = new Thread(new NewRunnableTerminated());

        System.out.println(thread.getState());//New
        thread.start();
        System.out.println(thread.getState());//Runnable
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //Runnable
        System.out.println(thread.getState());
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //TERMINATED
        System.out.println(thread.getState());
    }

    @Override
    public void run () {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
    }
}

输出

NEW
RUNNABLE
0
1
2
...
97
98
RUNNABLE
99
100
101
...
997
998
999
TERMINATED

/**
 * Blocked、Waiting、TimedWaiting
 */
public class BlockedWaitingTimedWaiting implements Runnable{
    public static void main (String[] args) {
        BlockedWaitingTimedWaiting runnable = new BlockedWaitingTimedWaiting();
        Thread thread1 = new Thread(runnable);
        thread1.start();

        Thread thread2 = new Thread(runnable);
        thread2.start();
        //打印出Timed_Waiting状态，因为正在执行Thread.sleep(1000)
        System.out.println(thread1.getState());
        //打印出Blocked状态，因为thread2想要拿到锁syn()却拿不到
        System.out.println(thread2.getState());
        try {
            Thread.sleep(1300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread1.getState());//WAITING
    }


    @Override
    public void run () {
        syn();
    }

    private synchronized void syn(){
        try {
            Thread.sleep(100);
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}