线程的生命周期

悠悠 2021-09-24 02:18 543阅读 0赞

## New 、Runnable、Blocked 、Waiting、Timed Waiting、Terminated ##

**查看线程的六种状态：`Stream.of(Thread.State.values()).forEach(System.out::println);`**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 1]  
**New**  
代表已创建但还没启动的新线程。就是指当我们new Thread之后还没有调用start()方法。此时线程就处于new这个状态。事实上我们new Thread建立了这个线程之后，它还没有开始运行，只是已经做了一些准备工作了，并没有运行run方法。

**Runnable**  
1、比较特殊的一种状态。一旦调用了start()方法就会处于Runnable状态。但是大家可能会想，调用了start()方法之后不见得会启动啊，有可能系统没有资源分配给他，那么它还处于等待啊。这个时候它的状态是Runnable还是Waiting呢？这里明确一下，一旦调用了start()方法，线程必然会处于Runnable状态。也就是说线程会从new->Runnable,而不会从new->Waiting。  
2、Runnable翻译为可运行的，而不是运行中的。 Java中的Runnable状态对应操作系统中的Ready和 Running两种状态 ，也就是Runnable既可以代表可运行的，又可以是实际运行中的。有可能正在执行，又有可能没有在执行。  
**Terminated**  
run()方法执行完毕或者出现了一些异常，意外终止也会进入Terminated状态。

## 代码演示以上三种状态 ##

package threadcoreknowledge.sixstates;
    
    /** * 描述： 展示线程的NEW、RUNNABLE、Terminated状态。即使是正在运行，也是Runnable状态，而不是Running。 */
    public class NewRunnableTerminated implements Runnable { 
    
        public static void main(String[] args) { 
            Thread thread = new Thread(new NewRunnableTerminated());
            //打印出NEW的状态
            System.out.println(thread.getState());
            thread.start();
            System.out.println(thread.getState());
            try { 
                Thread.sleep(10);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            //打印出RUNNABLE的状态，即使是正在运行，也是RUNNABLE，而不是RUNNING
            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);
            }
        }
    }

**Blocked**  
当一个线程进入synchronize修饰的方法或者代码块的时候，并且该锁已经被其他线程所拿走了，我们拿不到这把锁的时候， 这时的状态就是Blocked。仅仅针对synchronize关键字才能进入Blocked。因为和synchronize关键字起相似作用的关键字嗨哟Lock等各种各样的锁，但是那些情况都不是Blocked状态。

**Waiting**  
等待，哪些情况会进入这个状态呢？

1、没有设置Timeout参数的Object.wait() 方法。  
2、没有参数的Thread.join() 方法。  
3、没有参数的LockSupport.unpark()方法。

**Timed Waiting**  
计时等待，可以理解为和Waiting是兄弟关系，只不过Timed Waiting是有一定时间期限的，Waiting没有。哪些情况会进入这个状态呢？

1、设置了参数的Object.wait(time) 方法。  
2、设置了参数的Thread.sleep(time) 方法。  
3、设置了参数的Thread.join(time) 方法。  
4、设置了参数的LockSupport.parkNanos(time)方法。  
5、设置了参数的LockSupport.parkUntil(time)方法。

设置了参数的这些方法会等待超时，超时之后会唤醒。如果在超时之前使用Object.notify()、Object.notifyAll()、LockSupport.umpark()这些方法也会唤醒。

## 代码演示以上三种状态 ##

package threadcoreknowledge.sixstates;
    
    /** * 描述： 展示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();
            try { 
                Thread.sleep(5);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            //打印出Timed_Waiting状态，因为正在执行Thread.sleep(1000);
            System.out.println(thread1.getState());
            //打印出BLOCKED状态，因为thread2想拿得到sync()的锁却拿不到
            System.out.println(thread2.getState());
            try { 
                Thread.sleep(1300);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            //打印出WAITING状态，因为执行了wait()
            System.out.println(thread1.getState());
    
        }
    
        @Override
        public void run() { 
            syn();
        }
    
        private synchronized void syn() { 
            try { 
                Thread.sleep(1000);
                wait();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }

## 阻塞状态： ##

一般习惯而言，把 Blocked（被阻塞） Waiting（等待）Timed Waiting （计时等待）都称为阻塞状态，不仅仅是Blocked。

## 面试:线程有哪几种状态。根据状态间转化图示回答。 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70]: /images/20210923/fc55d86a089840c38dace66153a537a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70 1]: /images/20210923/a5cb2a7b7ced45e39798f4c48a2238d0.png