Java SE多线程部分--20.线程状态

版权声明：转载请注明原始链接 https://blog.csdn.net/sswqzx/article/details/82904025

1、概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，
有几种状态呢？在API中java.lang.Thread.State 这个枚举中给出了六种线程状态

2、Timed Waiting（计时等待）

static void	sleep(long millis) 
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），
此操作受到系统计时器和调度程序精度和准确性的影响。

sleep计时等待：

public class ThreadStatus {
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);   // 让当前线程进入到 `timed waiting` 计时等待状态.
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 时间到了自己醒了 ...");
                }
            }
        }, "计时等待线程").start();
    }
}

wait 方法计时等待 :

public class WaitTest2 {
    public static void main(String[] args) {

        // wait & notify 方法必须拥有 `同步锁` 环境.
        Object lock = new Object();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (lock) {
                        try {
                            lock.wait(1000);   // 当前线程就进入到计时等待状态.
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + " 1秒后, 自己醒了 ...");
                    }
                }
            }
        }, "计时等待").start();
    }
}

3、 BLOCKED（锁阻塞）

一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

4、 Waiting（无限等待）
一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态

 演示：

public class WaitTest3 {
    public static void main(String[] args) {

        Object lock = new Object();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    // `同步锁` 环境
                    synchronized (lock) {

                        // 死等
                        System.out.println(Thread.currentThread().getName() + " 进入到死等状态 ...");

                        try {
                            lock.wait();   // 让前线程进入到了 waiting 状态.
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                        // 唤醒
                        System.out.println(Thread.currentThread().getName() + " 从死等状态被唤醒 ...");
                    }
                }
            }
        }, "无限等待").start();

        // 模拟唤醒线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {

                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    // 锁环境
                    synchronized (lock) {
                        lock.notify(); // 唤醒在此监视器上等待的线程
                    }
                }
            }
        }, "唤醒线程").start();
    }
}