Java线程的生命周期，终止与复位

今天药忘吃喽~ 2023-10-01 22:30 0阅读 0赞

### Thread生命周期 ###

#### 生命周期概述 ####

Java的线程状态描述放在`Thread`类里面的枚举类`State`中.总共包含了6中状态（从出生到死亡）。

public enum State {
        /**
         * 尚未启动的线程的线程状态 （没有start）
         */
        NEW,
    
        /**
         * 可运行线程的线程状态，是可以运行的线程状态（并不是在运行）
         * 这个状态在Java虚拟机中进行，但它可能等待来自操作系统的其他资源，比如CPU。
         * 内部包含了两个状态 【RUNNING】,【READY】这两个状态是可以互相流转的
         * 调用了start后线程就处于 READY 状态 ，等待操作系统分配CPU时间片，分配后进入 RUNNING 状态。
         * 当调用 yield() 方法后，只是谦让的允许当前线程让出 CPU ，但是不一定让，由操作系统决定，如果让      * 了当前线程就会进入 READY 状态，等待系统分配CPU时间片再次进入 RUNNING 状态。
         */
        RUNNABLE,
    
        /**
         * 阻塞状态。
         * 线程阻塞，等待监视器锁的状态，获取监视器锁后会进入 RUNNABLE  状态
         * 当发生线程锁竞争状态下，没有获取到锁的线程会被挂起进入阻塞状态，比如synchronized锁。
         */
        BLOCKED,
    
        /**
         * 等待线程的线程状态
         * 线程调用以下方法会处于等待状态：Object.wait()不超时、Thread.join()不超时等方法
         * 一个处于等待状态的线程正在等待另一个线程执行特定动作，例如：
         * 一个线程调用了Object.wait()方法在一个对象上正在等待另一个线程调用Object.nofify()或者
         * Object.nofifyAll()方法开启那个对象
         * 一个调用了Thread.join()方法的线程正在等待指定线程终止
         */
        WAITING,
    
        /**
         * 具有指定等待时间的等待线程的线程状态，调用一下方法会处于这个状态： Object.wait() 超时、          * Thread.join()超时 Thread.sleep(long) 等方法 
         */
        TIMED_WAITING,
    
        /**
         * 已终止线程的线程状态
         * 线程执行完毕或者发生异常终止执行
         */
        TERMINATED;
    }

#### 线程生命周期流程图 ####

![format_png][]

#### 线程生命周期测试 ####

public class ThreadStatusDemo {
        public static void main(String[] args) throws InterruptedException {
            // 测试 NEW RUNNABLE TERMINATED
            Thread terminated_thread = new Thread(() -> {
                long start = System.currentTimeMillis();
                // 运行三秒 ,打印TERMINATED_THREAD线程runnable状态
                while (System.currentTimeMillis()-start<3000){}
            }, "TERMINATED_THREAD");
            // NEW
            Thread.State state = terminated_thread.getState();
            System.out.println(terminated_thread.getName()+" :state = " + state);
    
            terminated_thread.start();
            TimeUnit.SECONDS.sleep(1);
            // RUNNABLE
            Thread.State state1 = terminated_thread.getState();
            System.out.println(terminated_thread.getName()+"state1 = " + state1);
    
            TimeUnit.SECONDS.sleep(5);
            Thread.State state2 = terminated_thread.getState();
            // TERMINATED
            System.out.println(terminated_thread.getName()+"state2 = " + state2);
    
            // RUNNABLE
            new Thread(() -> {
                while (true) {
    
                }
            }, "Runnle_Thread").start();
    
    
            // TIMED_WAITING
            new Thread(() -> {
                while (true) {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "Time_Waiting_Thread").start();
            // WAITING
            new Thread(() -> {
                while (true) {
                    synchronized (ThreadStatusDemo.class) {
                        try {
                            ThreadStatusDemo.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "Waiting_Thread").start();
    
            // 这两个看谁先抢占到cpu获得锁,另一个就blocked
            // timed_waiting
            new Thread(new BlockedDemo(), "Blocke01_Thread").start();
            // blocked
            new Thread(new BlockedDemo(), "Blocke02_Thread").start();
    
        }
    
        static class BlockedDemo extends Thread {
            @Override
            public void run() {
                synchronized (BlockedDemo.class) {
                    while (true) {
                        try {
                            TimeUnit.SECONDS.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

![format_png 1][]

![format_png 2][]

### 启动线程 ###

#### java中的启动 ####

`Java`启动一个线程调用`start`方法,start方法内部调用了 `start0()`native方法。

public synchronized void start() {
        . . .
        boolean started = false;
        try { 
            // 调用native方法
            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 */
            }
        }
    }

这个测试是为了验证上图的正确性,只贴了部分.

#### Hotspot中的启动 ####

查看指引

![format_png 3][]

在`jvm.cpp`找到`JVM_StartThread`方法。发现是先创建个 `JavaThread`作为本地线程然后启动这个本地线程（借助os【thread.cpp】,因为jvm是跨平台的，这里是以linux-os为示例）

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
      JVMWrapper("JVM_StartThread");
      JavaThread *native_thread = NULL;
      bool throw_illegal_thread_state = false;
      {
        MutexLocker mu(Threads_lock);
        
        if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {
          throw_illegal_thread_state = true;
        } else {
          jlong size =
                 java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
          size_t sz = size > 0 ? (size_t) size : 0;
          // 先创建一个JavaThread
          native_thread = new JavaThread(&thread_entry, sz);
          if (native_thread->osthread() != NULL) {
            native_thread->prepare(jthread);
          }
        }
      }
      if (throw_illegal_thread_state) {
        THROW(vmSymbols::java_lang_IllegalThreadStateException());
      }
      assert(native_thread != NULL, "Starting null thread?");
      if (native_thread->osthread() == NULL) {
        delete native_thread;
        if (JvmtiExport::should_post_resource_exhausted()) {
          JvmtiExport::post_resource_exhausted(
            JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS,
            "unable to create new native thread");
        }
        THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),
                  "unable to create new native thread");
      }
      // 然后启动这个本地线程 thread.cpp
      Thread::start(native_thread);
    JVM_END

JavaThread 创建线程

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
      Thread()
    #if INCLUDE_ALL_GCS
      , _satb_mark_queue(&_satb_mark_queue_set),
      _dirty_card_queue(&_dirty_card_queue_set)
    #endif // INCLUDE_ALL_GCS
    {
      if (TraceThreadEvents) {
        tty->print_cr("creating thread %p", this);
      }
      initialize();
      _jni_attach_state = _not_attaching_via_jni;
      set_entry_point(entry_point);
      os::ThreadType thr_type = os::java_thread;
      thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
                                                         os::java_thread;
    
    // 调用os(操作系统)创建个线程            
      os::create_thread(this, thr_type, stack_sz);
      _safepoint_visible = false; 
       . . .
    }

thread.cpp 启动线程

// tips: 启动线程的方法
    void Thread::start(Thread* thread) {
      trace("start", thread);
      // Start is different from resume in that its safety is guaranteed by context or
      // being called from a Java method synchronized on the Thread object.
      if (!DisableStartThread) {
        if (thread->is_Java_thread()) {
          // Initialize the thread state to RUNNABLE before starting this thread.
          // Can not set it after the thread started because we do not know the
          // exact thread state at that time. It could be in MONITOR_WAIT or
          // in SLEEPING or some other state.
          // tips:启动之后设置线程的状态为 可运行状态 RUNNABLE
          java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
                                              java_lang_Thread::RUNNABLE);
        }
        // 借助操作系统启动线程
        os::start_thread(thread);
      }
    }

### 线程中断与复位 ###

#### 不要使用stop方法 ####

线程的终止不要简单的调用 `stop`方法，这个方法和其他的线程控制方法（`suspend`,`resume`）一样都是过期了不建议使用的，这些方法都是不安全的。 例如`stop()`方法在结束一个线程的时候并不保证线程资源的正常释放，因此可能导致出现一些不确定的状态。 按照人类逻辑来理解:T1线程调用方法修改T2线程的状态,但是T2现在在做什么T1是不清楚的，所以强制他关闭就是不安全的，就好比在`Linux`中使用 `kill -9` 杀掉一个进程。

#### 使用interrupt方法 ####

`interrupt()`方法只是修改了被中断线程的中断标志 ，并没有做什么过分的事儿。就像平时写代码的时候修改某对象的标志，对象自己通过标志类决定执行什么逻辑。这里也是一样，`interrupt()`方法修改中断标志，被中断的线程，自己决定做什么事儿(中断或者不中断都是被中断线程自己决定的，外部只是通知他，不是强迫他)。追一下源码。

1.Java调用`interrupt`方法

![format_png 4][]

2.通过指引找到 `jvm.cpp#JVM_Interrupt`方法

![format_png 5][]

thread.cpp interrupt 借用操作系统。直接通过系统调用 interrupt
    void Thread::interrupt(Thread* thread) {
      trace("interrupt", thread);
      debug_only(check_for_dangling_thread_pointer(thread);)
      // tips: 调用操作系统的interrupt方法
      os::interrupt(thread);
    }

这里还是以os\_linux.cpp为例最终调用osthread的set\_interrupted修改状态

![format_png 6][]

![format_png 7][]

这里就印证了上方的 `Thread.interrupt()`只是修改了线程的一个标志位 ，并没有做什么过分的事儿。

#### 线程的复位 ####

`interrupted`与`isInterrupted`

这两个放在一起是因为他们底层都是调用的同一个native方法`isInterrupted()`只是给了不同的入参。 再就是，有过面试官问到他两的区别，所以干脆放在一起。首先说结论 ，`isInterrupted()`会返回线程的中断状态，`interrupted()`不仅会返回中断状态，而且如果线程处于状态状态还会将线程终端状态复位(清除中断状态)。

![format_png 8][]

![format_png 9][]

![format_png 10][]

![format_png 11][]

os\_linux.cpp的`is_interrupted()`方法印证了上面说的`isInterrupted()`会返回线程的中断状态，`interrupted()`不仅会返回中断状态，而且如果线程处于状态状态还会将线程终端状态复位(清除中断状态)。

其他的线程复位

在`Java`中只要抛出了`InnterruptException`异常的方法都对线程进行了复位。先理顺下为什么要这么做:查看下基本上抛出`InnterruptException`异常的方法都是线程阻塞方法，比如`sleep()`,`wait()`,`join()`。这类方法执行后线程会处于`TIMED_WAITING`或者`WAITING`状态，处于这类状态的线程是不受控的（线程丧失了对自己的主导，需要其他的线程唤醒，或者阻塞时间到达才能拥有自己的主导权）,这个时候线程中断，线程自己却没办法处理。甚至可能永远等不到释放而无法执行中断。所以，在线程是中断状态下，执行方法让线程阻塞,就要抛出一个异常告诉外界 ，我现在是阻塞状态，并且将中断标记复位，方便外界进行处理(例如中断线程的执行或者继续阻塞方法),相当于给了外界一个改变线程状态的入口。 以`sleep()`为例追踪下源码:

![format_png 12][]

通过指引找到 `jcm.cpp#JVM_Sleep`

![format_png 13][]

方法入口就直接判断线程的中断状态了 ，`is_interrupted()`上面介绍过了，参数为`true`就是清除中断标志并且返回清除之前的中断状态。这里线程是中断状态的就直接抛出 `InnterruptException sleep interrupted`异常了。

![5d1b594fe682448da2dd29dc95f53d68.jpeg][]

[format_png]: https://img-blog.csdnimg.cn/img_convert/7fa7e31d36e42318c55ac9b1f94649d8.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/072633ea2e7e85a1d282b790330ded12.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/d07f80d3eb207f624b97df937d73b1a1.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/f72f6f9e85a3087fee31d59e98112a4f.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/82c07cfe0d21b63388d43ed92b11e5c0.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/d4d9d16d57c43dd6a13fdce3a655ecf9.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/07875efd3996230b8051c5297746a531.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/88fb819bc97991614b8ae33b716d981e.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/d8fcacb0b2c5e716011988f8c22854e7.webp?x-oss-process=image/format,png
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/c45577f7f380b753664aed69fb8f68a9.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/43557d923812ad6bfff9ca19671f355b.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/a4df7d3bcc22e5ce9febc4a7ff80cdb8.webp?x-oss-process=image/format,png
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/e15f20e10925fc162fca983c29c7bb7a.webp?x-oss-process=image/format,png
[format_png 13]: https://img-blog.csdnimg.cn/img_convert/304134c45f65990f4a46f37b0168f5d1.webp?x-oss-process=image/format,png
[5d1b594fe682448da2dd29dc95f53d68.jpeg]: https://img-blog.csdnimg.cn/5d1b594fe682448da2dd29dc95f53d68.jpeg