Java技术指南「难点-核心-遗漏」Java线程状态流转及生命周期的技术指南（知识点串烧）！

Posted 2021-09-08 李浩宇Alex

前提介绍

线程状态流转及生命周期

生命周期的六种状态

 public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

---

新建（new Thread）

• 当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。

• 使用new创建一个线程对象，仅仅在堆中分配内存空间，在调用start方法之前。 新建状态下，线程压根就没有启动,仅仅只是存在一个线程对象而已.Thread t = new Thread();

• 此时t就属于新建状态当新建状态下的线程对象调用了start方法,此时从新建状态进入可运行状态.线程对象的start方法只能调用一次,否则报错:IllegalThreadStateException.

例如

Thread  t1=new Thread();

---

可运行（runnable）

就绪状态

运行状态

• 被转换成Terminated状态，比如调用 stop() 方法;

• 被转换成Blocked状态，比如调用了sleep, wait 方法被加入 waitSet 中；

• 被转换成Blocked状态，如进行 IO 阻塞操作，如查询数据库进入阻塞状态；

• 被转换成Blocked状态，比如获取某个锁的释放，而被加入该锁的阻塞队列中；

• 该线程的时间片用完，CPU 再次调度，进入Runnable状态；

• 线程主动调用 yield 方法，让出 CPU 资源，进入Runnable状态

例如

t1.start();

运行（running）他也从属于Runnable状态，但不在总体状态之内，属于逻辑状态机制

注意：

堵塞（blocked）

阻塞状态的两种情况:

1. 当A线程处于运行过程时,试图获取同步锁时,却被B线程获取.此时JVM把当前A线程存到对象的锁池中,A线程进入阻塞状态.
2. 当线程处于运行过程时,发出了IO请求时,此时进入阻塞状态.

• 被转换成Terminated状态，比如调用 stop() 方法，或者是 JVM 意外 Crash;

• 被转换成Runnable状态，阻塞时间结束，比如读取到了数据库的数据后；

• 完成了指定时间的休眠，进入到Runnable状态；

• 正在wait中的线程，被其他线程调用notify/notifyAll方法唤醒，进入到Runnable状态；

• 线程获取到了想要的锁资源，进入Runnable状态；

• 线程在阻塞状态下被打断，如其他线程调用了interrupt方法，进入到Runnable状态；

等待状态(waiting)

此时使用的无参数的wait方法,

1. 当线程处于运行过程时,调用了wait()方法,此时JVM把当前线程存在对象等待池中.

计时等待状态(timed waiting)

(使用了带参数的wait方法或者sleep方法)

1. 当线程处于运行过程时,调用了wait(long time)方法,此时JVM把当前线程存在对象等待池中.
2. :当前线程执行了sleep(long time)方法.

终止状态(terminated)

1. 正常执行完run方法而退出(正常死亡).
2. 遇到异常而退出(出现异常之后,程序就会中断)(意外死亡).
3. JVM 异常结束，所有的线程生命周期均被结束。

不推荐使用的线程方法

• void suspend() :暂停当前线程
• void resume() :恢复当前线程
• void stop() :结束当前线程

---

给大家结合官网在进行一个中文解释的状态流转图：