线程的生命周期

男娘i 2022-10-31 00:37 238阅读 0赞

# 线程的状态 #

线程的生命周期中大体可分为以下6种状态：

1.  NEW
2.  RUNNABLE
3.  BLOCKED
4.  WAITING
5.  TIMED\_WAITING
6.  TERMINATED

在Thread类中有个内部枚举类State用来表示线程的状态：

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

下面是线程各种状态之间的变换图：

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

## NEW（初始化）状态 ##

实例化一个Thread类对象出来（未执行start()方法前），Thread的状态为NEW。

## RUNNABLE（可运行）状态 ##

调用线程的start()方法，此时线程进入RUNNABLE状态，该状态的线程位于可运行线程池中，等待被操作系统调度，获取CPU的使用权。

当获得CPU的时间片时，线程进入运行状态，执行程序代码。

## BLOCKED（阻塞）状态 ##

当线程等待获取monitor锁（synchronized）时，线程就会进入BLOCKED状态。

注意：

*  等待获取monitor锁，线程的状态是BLOCKED。
 *  等待获取Lock锁（LockSupport.park()），线程的状态是WAITING。

## TIMED\_WAITING（超时等待）状态 ##

*  当执行Thread.sleep(time)  
    、Thread.join(time)  
    、Object.wait(time)  
    、LockSupport.parkNanos(time)  
    、LockSupport.partUntil(time)等操作时，线程会从RUNNABLE状态进入TIMED\_WAITING状态。
 *  当执行超时时间到  
    、Thread.join()线程执行完  
    、Object.notify()/notifyAll()  
    、LockSupport.unpark()  
    、线程被中断等操作时，线程会从TIMED\_WAITING状态进入RUNNABLE状态。

## WAITING（等待）状态 ##

*  当执行Object.wait()、Thread.join()、LockSupport.park()等操作时，线程会从RUNNABLE状态进入WAITING状态。
 *  当执行Object.notify()/notifyAll()、Thread.join()程序执行完、LockSupport.unpark()、线程被中断等操作时，线程会从WAITING状态进入RUNNABLE状态。

## TERMINATED（终止）状态 ##

当线程执行完毕、Thread.stop()、内存溢出时，线程就会进入TERMINATED状态。

线程一旦死亡，就无法复活。在一个死亡的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

## 操作系统中进程（线程）的生命周期 ##

操作系统中进程（线程）的状态有：

1.  新建
2.  就绪
3.  运行
4.  阻塞
5.  终止

进程的各种状态之间的转换：

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

一个进程在运行期间，不断地从一种状态转换到另一种状态，它可以多次处于就绪状态和执行状态，也可以多次处于阻塞状态。

### 新建->就绪 ###

进程刚创建出来就是新建状态，当资源分配完毕后就会变成就绪状态。

### 就绪→执行 ###

处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成执行状态。

### 执行→就绪 ###

处于执行状态的进程在其执行过程中，因分配给它的一个时间片已用完或更高优先级的进程抢占而不得不让出CPU，于是进程从执行状态转变成就绪状态。

### 执行→阻塞 ###

正在执行的进程因等待某种事件发生而无法继续执行时，便从执行状态变成阻塞状态。

### 阻塞→就绪 ###

处于阻塞状态的进程，若其等待的事件已经发生，于是进程由阻塞状态转变为就绪状态。

### 运行→终止 ###

程序执行完毕就会变成终止状态。

## Java中线程的状态与操作系统中线程的对应关系 ##

<table> 
 <thead> 
  <tr> 
   <th>java</th> 
   <th>操作系统</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>NEW</td> 
   <td>新建</td> 
  </tr> 
  <tr> 
   <td>RUNNABLE</td> 
   <td>就绪、运行、部分阻塞</td> 
  </tr> 
  <tr> 
   <td>TIMED_WAITING</td> 
   <td>阻塞</td> 
  </tr> 
  <tr> 
   <td>WAITING</td> 
   <td>阻塞</td> 
  </tr> 
  <tr> 
   <td>BLOCKED</td> 
   <td>阻塞</td> 
  </tr> 
  <tr> 
   <td>TERMINATED</td> 
   <td>终止</td> 
  </tr> 
 </tbody> 
</table>

在操作系统中，等待IO资源时，进程的状态为阻塞状态，而JVM 并不关心操作系统线程的实际状态，从JVM看来，等待CPU使用权（操作系统状态为可运行态）与等待 I/O（操作系统处于阻塞状态）没有区别，都是在等待某种资源，所以都归入RUNNABLE状态  
。

# 线程状态变化演示 #

## Thread从运行到死亡状态的变化 ##

package com.morris.concurrent.thread.lifecycle;
    
    import java.util.concurrent.TimeUnit;
    
    /** * 演示Thread生命周期中状态的变化 */
    public class ThreadDemo { 
    
        public static void main(String[] args) throws InterruptedException { 
    
            Thread thread = new Thread(() -> { 
    
                System.out.println("线程运行中:" + Thread.currentThread().getState());
                try { 
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
            });
    
            System.out.println("新建一个线程: " + thread.getState());
    
            thread.start();
    
            // 主线程休眠1s，等待thread运行
            TimeUnit.SECONDS.sleep(1);
    
            System.out.println("线程休眠中：" + thread.getState());
    
            // 主线程休眠14，等待thread死亡
            TimeUnit.SECONDS.sleep(4);
            System.out.println("线程死亡：" + thread.getState());
    
        }
    }

运行结果如下：

新建一个线程: NEW
    线程运行中:RUNNABLE
    线程休眠中：TIMED_WAITING
    线程死亡：TERMINATED

## 等待获取synchronized锁线程的状态演示 ##

package com.morris.concurrent.thread.lifecycle;
    
    import java.util.concurrent.TimeUnit;
    
    /** * 演示等待获取synchronized锁线程的状态 */
    public class SynchronizedDemo { 
    
        public static void main(String[] args) throws InterruptedException { 
    
            Object lock = new Object();
    
            Runnable r = () -> { 
                synchronized (lock) { 
                    try { 
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            };
    
            Thread t1 = new Thread(r);
            t1.start();
    
            // 主线程等待线程t1运行
            TimeUnit.SECONDS.sleep(1);
    
            Thread t2 = new Thread(r);
            t2.start();
    
            // 主线程等待线程t2运行
            TimeUnit.SECONDS.sleep(1);
    
            System.out.println("等待获取synchronized锁线程的状态：" + t2.getState()); // BLOCKED
        }
    }

## 等待获取Lock锁线程的状态演示 ##

package com.morris.concurrent.thread.lifecycle;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /** * 演示等待获取Lock锁线程的状态 */
    public class LockDemo { 
    
        public static void main(String[] args) throws InterruptedException { 
    
            Lock lock = new ReentrantLock();
    
            Runnable r = () -> { 
                lock.lock();
                try { 
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } finally { 
                    lock.unlock();
                }
            };
    
            Thread t1 = new Thread(r);
            t1.start();
    
            // 主线程等待线程t1运行
            TimeUnit.SECONDS.sleep(1);
    
            Thread t2 = new Thread(r);
            t2.start();
    
            // 主线程等待线程t2运行
            TimeUnit.SECONDS.sleep(1);
    
            System.out.println("等待获取Lock锁线程的状态：" + t2.getState()); // WAITING
        }
    }

## 等待获取IO资源的线程的状态 ##

import java.io.IOException;
    import java.util.Scanner;
    import java.util.concurrent.TimeUnit;
    
    /** * 演示IO阻塞时的状态 */
    public class IOStateDemo { 
    
        public static void main(String[] args) throws IOException, InterruptedException { 
    
            Thread thread = new Thread(() -> { 
                Scanner scanner = new Scanner(System.in);
                scanner.next();
            });
            thread.setDaemon(true);
            thread.start();
            TimeUnit.SECONDS.sleep(1); // wait thread start
    
            System.out.println(thread.getState()); // RUNNABLE
        }
    }

# 线程start()方法源码分析 #

先来看下start()方法的源码：

// synchronized同步方法，保证线程只能执行一次
        public synchronized void start() { 
    
            // 线程start()后不能再次start()，否则抛出IllegalThreadStateException异常
            if (threadStatus != 0) // 0对应NEW状态
                throw new IllegalThreadStateException();
            // 将当前线程加入线程组，默认是父线程的线程组
            group.add(this);
    
            boolean started = false;
            try { 
                // 本地方法
                start0();
                started = true;
            } finally { 
                try { 
                    if (!started) { 
                        group.threadStartFailed(this);
                    }
                } catch (Throwable ignore) { 
                    /* do nothing. If start0 threw a Throwable then it will be passed up the call stack */
                }
            }
        }
    
        private native void start0();

从源码可以看出run()方法应该是在本地方法start0中被调用。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/a680db331ba54d99bd47202448d02401.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/e4739741a0324dd8aa121d2580df93be.png