并发编程之三：线程状态

╰半橙微兮° 2022-12-25 06:56 153阅读 0赞

### 线程状态 ###

*  线程的五种？六种状态？
 *   *  五种状态(从操作系统的层面描述)
     *  线程的六种状态(javaAPI层面描述)
     *   *  线程的六种状态(javaAPI层面描述)
         *  代码实现java中线程的6种状态(简单实现)
         *   *  NEW(初始状态)
             *  RUNNABLE(运行状态)
             *  TERMINATED(终止状态)
             *  TIMED\_WAITING(有时限的等待)
             *  WAITING(无时限的等待)
             *  BLOCKED(没有获取到锁资源)
     *  习题 ：华罗庚统筹方法（烧水泡茶多线程最优解决方案）
     *  java代码实现各个线程状态的转换(加强)
     *   *  NEW --> RUNNABLE
         *  转换一：RUNNABLE <--> WAITING
         *   *  情况2：wait/notify方法
             *  情况3：join方法
             *  情况4：park/unpark方法
         *  转换二：RUNNABLE<--> WAITING
         *   *   *  情况5 obj.wait(long n),obj.notify,obj.notifyAll()
                 *  情况6 join,interrupt
                 *  情况7 sleep
                 *  情况8 parkNanos,parkUntil
         *  转换三：RUNNABLE<--> BLOCKED
         *   *   *  情况9 synchronized
         *  转换四：RUNNABLE<--> TERMINATED
         *   *   *  情况10 TERMINATED

# 线程的五种？六种状态？ #

## 五种状态(从操作系统的层面描述) ##

**线程的五种状态是从操作系统的层面来描述的**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70]

*  **【初始状态】**：仅是在语言层面创建了线程对象，还未与操作系统线程关联。栗子：java中new了一个Thread对象，但是没有调用它的start方法。
 *  **【可运行状态(就绪状态)】**：指该线程已被创建(与操作系统线程关联)，可由cpu调度执行。栗子：java中调用一个线程对象的start方法，但是线程还没有获取cpu时间片。
 *  **【运行状态】**：指获取了CPU时间片运行中的状态。栗子：线程获取了cpu时间片正在执行线程中代码的那些线程，如开启start方法后，执行其中run方法里的代码块的线程。
    
     *  当CPU时间片用完，会从\[运行状态\]转换至\[可运行状态\]，会导致线程的上下文切换(线程从使用cpu到不使用cpu叫做线程的上下文切换)
 *  **【阻塞状态】**：如果调用了阻塞API,如BIO读写文件,这时该线程实际不会用到CPU，会让出cpu时间片,会导致线程上下文切换，进入【阻塞状态】（sleep,wait,IO操作都称为线程的阻塞）
    
     *  等BIO操作完毕，会由操作系统唤醒阻塞的线程,转换至\[可运行状态\]
     *  与\[可运行状态\]的区别是，对\[阻塞状态\]的线程来说只要它们一-直不唤醒，调度器就一-直不会考  
        虑调度它们。唤醒之后线程不会立刻进入运行状态，而是进入可运行状态，等待线程获取cpu时间片然后才会进入运行状态。
 *  **【终止状态】**：表示线程已经执行完毕,生命周期已经结束，不会再转换为其它状态。

## 线程的六种状态(javaAPI层面描述) ##

### 线程的六种状态(javaAPI层面描述) ###

哪来的六种状态？多了一种？老王的？答案呼之欲出, 令人倒吸一口冷气。  
**其实线程的6种状态是从javaAPI层面来描述的，Thread.State枚举，它把线程分为6中状态**

我们来看下源码，Thread的1742行代码开始。所以线程的6中状态一般都是从java的层面来描述的。javaAPI确定的把线程分成了6中状态。

public enum State { 
            NEW,
            RUNNABLE,
            BLOCKED,
            WAITING,
            TIMED_WAITING,
            TERMINATED;
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAamF2YV94eHh4_size_20_color_FFFFFF_t_70_g_se_x_16]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 2]

*  **【NEW】**：线程刚被创建，但是还没有调用start()方法.
 *  **【RUNNABLE】**：当调用了start()方法之后，注意, Java API层面的RUNNABLE状态涵盖了操作系统层面的  
    \[可运行状态\]、\[运行状态\] 和\[阻塞状态\] (由于 BIO导致的线程阻塞，在Java里无法区分,仍然认为是可运行，sleet,wait,IO操作都是阻塞)
 *  **【TERMINATED】**： 终止状态。线程内代码已经运行结束，它不会再转为其他状态。

### 代码实现java中线程的6种状态(简单实现) ###

以下代码中所有获取线程状态之前都让主线程(main)方法睡了一会，是因为在主线程中获取线程的状态时，确保线程进入相应的睡眠或者阻塞以得到正确的状态，否则线程还没有睡眠就获取它们的状态，那么线程只要是调用了start方法就都是RUNNABLE状态了。注：sleep,wait,IO操作都是线程的阻塞。

#### NEW(初始状态) ####

线程的就绪状态：只是创建了线程对象，没有调用start方法

public class ThreadStatus {
        public static void main(String[] args) {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("创建状态");
                }
            });
            // 线程的就绪状态：只是创建了线程对象，没有调用start方法
            System.out.println("就绪状态：" + t1.getState());
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 3]

#### RUNNABLE(运行状态) ####

这里的运行状态是java中的运行状态：相当与操作系统中的，可运行状态(就绪状态)，运行状态，阻塞状态。

// java中的运行状态RUNNABLE
        public static void t2() {
            // 运行状态：
            // java中的运行状态：相当与操作系统中的，可运行状态(就绪状态)，运行状态，阻塞状态
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
    
                    }
                }
            });
            t2.start();
            System.out.println("运行状态 ：" + t2.getState());
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 4]

#### TERMINATED(终止状态) ####

// TERMINATED(终止状态)
        public static void t3() throws InterruptedException {
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("终止状态：");
                }
            });
            t3.start();
            // 主线程睡1s，此时线程t3早已运行完毕，便是终止状态
            Thread.sleep(1000);
            System.out.println("终止状态：" + t3.getState());
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 5]

#### TIMED\_WAITING(有时限的等待) ####

超时等待(TIMED\_WAITING)  
处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

public static void t4() throws InterruptedException {
            Thread t4 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (ThreadStatus.class) {
                        try {
                            Thread.sleep(10000000); // timed_waiting
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            t4.start();
            Thread.sleep(500);
            System.out.println(t4.getState());
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 6]

#### WAITING(无时限的等待) ####

处于这种状态的线程不会得到任务调度器的调度，也就不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

// waiting
        public static void t5 () {
            Thread t5 = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
    
                    }
                }
            });
            t5.start();
            Thread t6 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // t5是个死循环，join方法就是等待调用的那个线程执行完再执行下面的任务，所以t6会一直等待
                        t5.join(); // 因为这种等待就没有加时限，所以是waiting
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t6.start();
            System.out.println(t6.getState());
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 7]

#### BLOCKED(没有获取到锁资源) ####

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。也就是线程没有获得资源锁。即：线程阻塞于锁。

// blocked
        public static void t6() throws InterruptedException {
            Thread t7 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (ThreadStatus.class) {
                        try {
                            Thread.sleep(1000000); // timed_waiting
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            t7.start();
    
            Thread t8 = new Thread(new Runnable() {
                @Override
                public void run() {
                    // blocked
                    // t7已经对ThreadStatus加了锁，但是在t7还没有释放锁资源之前，t8是拿不到锁资源的，于是就是
                    synchronized (ThreadStatus.class) {
                        try {
                            Thread.sleep(1000000); // timed_waiting
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            t8.start();
            Thread.sleep(500);
            System.out.println("" + t8.getState());
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 8]  
以上只是浅显的说了一下线程的状态问题，以后的博客会深入的学习一下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 9]

## 习题 ：华罗庚统筹方法（烧水泡茶多线程最优解决方案） ##

华罗庚《统筹方法》  
统筹方法，是一种安排工作进程的数学方法。它的实用范围极广泛，在企业管理和基本建设中，以及关系复杂的科研项目的组织与管理中，都可以应用。  
怎样应用呢?主要是把工序安排好。  
比如，想泡壶茶喝。当时的情况是:开水没有;水壶要洗，茶壶、茶杯要洗;火已生了，茶叶也有了。怎么办?  
·办法甲:洗好水壶，灌上凉水，放在火上;在等待水开的时间里，洗茶壶、洗茶杯、拿茶叶;等水开了，泡茶喝。  
·办法乙∶先做好一些准备工作，洗水壶，洗茶壶茶杯，拿茶叶;一切就绪，灌水烧水;坐待水开了，泡茶喝。  
·办法丙:洗净水壶，灌上凉水，放在火上，坐待水开;水开了之后，急急忙忙找茶叶，洗茶壶茶杯，泡茶喝。  
哪一种办法省时间?我们能一眼看出，第一种办法好，后两种办法都窝了工。这是小事，但这是引子，可以引出生产管理等方面有用的方法来。  
水壶不洗，不能烧开水，因而洗水壶是烧开水的前提。没开水、没茶叶、不洗茶壶茶杯，就不能泡茶，因而这些又是泡茶的前提。它们的相互关系，可以用下边的箭头图来表示:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 10]  
图一  
从这个图上可以一眼看出，办法甲总共要16分钟（而办法乙、丙需要20分钟)。如果要缩短工时、提高工作效率，应当主要抓烧开水这个环节，而不是抓拿茶叶等环节。同时，洗茶壶茶杯、拿茶叶总共不过4分钟，大可利用“等水开”的时间来做。  
是的，这好像是废话，卑之无甚高论。有如走路要用两条腿走，吃饭要一口一口吃，这些道理谁都懂得。但稍有变化，临事而迷的情况，常常是存在的。在近代工业的错综复杂的工艺过程中，往往就不是像泡茶喝这么简单了。任务多了，几百几千，甚至有好几万个任务。关系多了，错综复杂，千头万绪，往往出现“万事俱备，只欠东风”"的情况。由于一两个零件没完成，耽误了一台复杂机器的出厂时间。或往往因为抓的不是关键，连夜三班，急急忙忙，完成这一环节之后，还得等待旁的环节才能装配。  
洗茶壶，洗茶杯，拿茶叶，或先或后，关系不大，而且同是一个人的活儿，因而可以合并成为:  
![图二][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 11]  
图二  
图一相当于启动了4个线程有点浪费。所以我们可以让a线程串行的洗水壶，然后再烧开水。然后b线程并行的洗茶壶，洗茶杯，拿茶叶。当a开始烧开水的时候，b也可以执行了。  
等水烧开的时候，两个线程再一起去泡茶。  
·参考图二，用两个线程(两个人协作）模拟烧水泡茶过程·文中办法乙、丙都相当于任务串行  
而图一相当于启动了4个线程，有点浪费·用sleep(n)模拟洗茶壶、洗水壶等耗费的时间

模拟t2泡茶

public class Test {
        public static void main(String[] args) {
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":洗水壶...");
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + ":烧开水...");
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "西门吹雪");
    
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":洗茶壶...");
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + ":洗茶杯...");
                        Thread.sleep(2000);
                        System.out.println(Thread.currentThread().getName() + ":拿茶叶...");
                        Thread.sleep(1000);
                        // 肯定的有个人去泡茶，所以这里我们让t2等待水烧开了，然后去泡茶
                        t1.join();
                        System.out.println(Thread.currentThread().getName() + ":泡茶...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "司徒摘星");
            t1.start();
            t2.start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 12]  
解法1的缺陷:  
上面模拟的是t2等t1的水烧开了，t2泡茶，如果反过来要实现t1等t2的茶叶拿来了，t1泡茶呢?代码最好能适应两种情况  
·上面的两个线程其实是各执行各的，如果要模拟t1把水壶交给t2泡茶，或模拟t2把茶叶交给t1泡茶呢?  
九层之台,起于垒土，一步步来，在后续的博客中，会优化这个解决方案。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 13]

## java代码实现各个线程状态的转换(加强) ##

1、下图中双向箭头表示状态之间的相互转换，单向箭头表示单向转换。  
2、2、3、43个箭头都可以互相转换，表示的是不同的方法去实现状态之间的转换  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 14]  
下文中情况1、2、3…分别代表的是箭头中的1，2，3…

### NEW --> RUNNABLE ###

情况1 NEW --> RUNNABLE  
当调用t.start()方法时,由NEW --> RUNNABLE

### 转换一：RUNNABLE <–> WAITING ###

#### 情况2：wait/notify方法 ####

t线程用synchronized(obj) 获取了对象锁后

1.  调用obj .wait()方法时，t线程从RUNNABLE --> WAITING
2.  调用obj . notify(), obj .notifyA11(), t. interrupt()时  
    2.1、竞争锁成功，t线程从WAITING --> RUNNABLE  
    2.2、竞争锁失败，t线程从WAITING --> BLOCKED

注意，以下代码调试时采用Thread方式，即一个线程在运行时，其它线程不会干扰  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 15]

代码实现：

package status;
    /** * @Author: llb * @Date: 2021/6/1 15:54 */
    public class ThreadStatus { 
        final static Object obj = new Object();
    
        public static void main(String[] args) throws InterruptedException { 
            new Thread(() -> { 
                synchronized (obj) { 
                    logger.log(Thread.currentThread().getName() + ":执行...");
                    try { 
                        // 让线程在obj上一直等待下去
                        obj.wait();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    logger.log(Thread.currentThread().getName() +"其它代码...");
                }
            }, "t1").start();
    
            new Thread(() -> { 
                synchronized (obj) { 
                    logger.log(Thread.currentThread().getName() + ":执行...");
                    try { 
                        // 让线程在obj上一直等待下去
                        obj.wait();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    logger.log(Thread.currentThread().getName() +"其它代码...");
                }
            }, "t2").start();
    
            // 主线程2s后执行
            Thread.sleep(2000);
            logger.log("唤醒obj上的其它线程...");
            synchronized (obj) { 
                // 唤醒obj上所有等待的线程，既然唤醒所有线程，那么就意味着有一个可以得到锁资源，另一个仍旧等待
                obj.notifyAll();
            }
        }
    }

图中所示加入3个断点  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 16]  
控制台打印  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 17]  
debug模式运行main方法,刚一运行，因为主方法没有执行完毕notifyAll方法，线程1、2均在等待状态。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 18]  
执行debug的下一步，此时线程1、2仍然得不到锁，因为主线程还有个大括号没运行完，就是这么皮。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 19]  
所以线程1、2此时状态应该是block,但是idea里的调试显示monitor，这里我们知道就可以了，调试工具的问题。因为主线程执行了notifyAll方法，此时线程1、2在Monitror里的entryList堵塞队列里等待竞争锁，它对应的java里的线程状态是blocked。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 20]

此时我们再往下执行一步，那么主线程就把这个锁给释放开了，然后线程1和线程2就会有一个得到锁，有一个竞争锁资源失败。  
结果：我们看到t2得到了锁资源处于running状态，然后t1是block状态，它就在monitor里的entryList等待锁竞争锁资源。**当线程竞争锁失败，之后线程就会进入BLOCKED状态,竞争锁成功就是RUNNING状态**。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 21]  
等到t2执行完毕后t1就得到了资源锁，此时t1就是运行中的状态  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 22]

#### 情况3：join方法 ####

情况3 RUNNABLE<–> WAITING

1.  ·当前线程调用:.join()方法时，当前线程从「RUNNABLE --> WAITING  
    1.2. 注意是当前线程在t线程对象的监视器上等待
2.  t线程运行结束，或调用了当前线程的interrupt()时，当前线程从wAITING --> RUNNABLE
3.

比如我想让主线程在t线程执行结束之后再执行，那么就在主线程main方法里调用t.join

#### 情况4：park/unpark方法 ####

情况4 RUNNABLE<–> WAITING

1.  当前线程调用LockSupport.park()方法会让当前线程从RUNNABLE --> WAITING
2.  ·调用LockSupport.unpark(目标线程）或调用了线程的interrupt()，会让目标线程从WAITING–>RUNNABLE

### 转换二：RUNNABLE<–> WAITING ###

##### 情况5 obj.wait(long n),obj.notify,obj.notifyAll() #####

**t线程用synchronized(obj)获取了对象锁后**

1.  调用obj.wait(long n)方法时，t线程从RUNNABLE -->TIMED\_WAITING
2.  t线程等待时间超过了n毫秒，或调用obj.notify()，obj.notifyAll()， t.interrupt()时  
    2.1竞争锁成功，t线程从TIMED\_wAITING -->RUNNABLE  
    2.2竞争锁失败，t线程从TIMED\_WAITING --> BLOCKED

##### 情况6 join,interrupt #####

情况6 RUNNABLE<–>TIMED\_WAITING

1.  ·当前线程调用\`t.join(long n)'方法时，当前线程从RUNNABLE -->TIMED\_MAITING  
    1.2. 注意是当前线程在t线程对象的监视器上等待。
2.  **当前线程**等待时间超过了n毫秒，或**t线程**运行结束，或调用了**当前线程**的interrupt()时，**当前线程**从RUNNABLE<–>TIMED\_WAITING

##### 情况7 sleep #####

情况7 RUNNABLE<–>TIMED\_WAITING

1.  当前线程调用Thread.sleep(long n)，当前线程从RUNNABLE -->TIMED\_WAITING
2.  当前线程等待时间超过了n毫秒，当前线程从TIMED\_WAITING --> RUNNABLE

##### 情况8 parkNanos,parkUntil #####

情况8RUNNABLE <–>TIMED\_WA工TING

1.  当前线程调用LockSupport.parkNanos(long nanos)或LockSupport.parkUntil(long millis)时，当前线程从RUNNABLE -->TIMED\_WAITING
2.  调用LockSupport.unpark(目标线程）或调用了线程的interrupt()，或是等待超时，会让目标线程从TIMED\_WAITING–>RUNNABLE

### 转换三：RUNNABLE<–> BLOCKED ###

##### 情况9 synchronized #####

情况9 RUNNABLE<–>BLOCKED

1.  t线程用synchronized(obj)获取了对象锁时如果竞争失败，从 RUNNABLE -->BLOCKED
2.  持obj锁线程的同步代码块执行完毕，会唤醒该对象上所有BLocKED 的线程重新竞争，如果其中t线程竞争成功，从 BLOCKED -->RUNNABLE，其它失败的线程仍然BLOCKED.

### 转换四：RUNNABLE<–> TERMINATED ###

##### 情况10 TERMINATED #####

情况10 RUNNABLE<–>TERMINATED

当前线程所有代码运行完毕，进入TERMINATED

个人学习笔记，不喜勿喷。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70]: /images/20221120/8f11a881e0e24dedb3f78a18002d3ab2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 1]: /images/20221120/9447c52bcf694677b263488818eea623.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAamF2YV94eHh4_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221120/1f60172aeb7d4e7b9d69c20a7e996b2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 2]: /images/20221120/f44a482d28bf4896a1e36b901d4ca46f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 3]: /images/20221120/692c45b08c614056b0f76acdac049e12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 4]: /images/20221120/db19bb89255745748ef91ea85779d979.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 5]: /images/20221120/6dbaad8a2a7b4a7e8aae17f08d7f3874.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 6]: /images/20221120/25246b3fa05249d4a8952722544db03e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 7]: /images/20221120/e9f9e97bc0fa46b598505f6c10cd4585.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 8]: /images/20221120/aa213ec3d6f94fc7b926f63c444179bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 9]: /images/20221120/8cf932a854d64967a8bb2aaeedeb3651.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 10]: /images/20221120/57962cc92188458e99463398cece40a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 11]: /images/20221120/fe61e8fa5967472ba1b4df492d77225c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 12]: /images/20221120/e4508db2f43448e6939c61fb9e150148.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 13]: /images/20221120/35b847af23b44834bc782b8477875181.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 14]: /images/20221120/a384512292964eebb096717ee9a549ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 15]: /images/20221120/9734e62cf562466096db359c8d0c33a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 16]: /images/20221120/6367b29fc078439ea6598022a5d8f54c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 17]: /images/20221120/b9c31c2ed55a440dbe8c323c7150b22d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 18]: /images/20221120/d4ca64af8ba64738aa603bd615bcd419.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 19]: /images/20221120/608e5e88e3484820bbd768f86a947acc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 20]: /images/20221120/5a3d12b7e0c94f87a2812f0e6a6f744a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 21]: /images/20221120/a8609589721748a18a7a03eb50321670.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phdmFfeHh4eA_size_16_color_FFFFFF_t_70 22]: /images/20221120/538c6080567640b283915e2138c1725a.png