Java线程的生命周期

Java线程的生命周期

起因

当想了解Java生命周期时，发现网上有的博客介绍的是五种状态，有的介绍的是六种状态。

因此，翻阅资料了解了下Java线程的生命周期

Java线程生命周期

那么Java线程的生命周期到底是分为五种还是六种呢？

其实出现此情况的原因是根据不同的层面看，就有不同的结果。

一般是分为操作系统和Java Api两个层面来分析Java线程生命周期。

基于操作系统划分线程生命周期

• 初始状态(New)
• 可运行状态(Runnable)
• 运行状态(Running)
• 阻塞状态(Blocked)
• 死亡状态(Dead)

这时基于操作系统的划分，我们在这不展开讨论，关键来看看基于Java Api 层面划分的线程生命周期

基于Java Api 划分的线程生命周期

首先我们来看看Java源码中Thread.State枚举类：

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;
}

可以很清晰的看到，在Java层面上是将线程生命周期分为六种状态。

那么我们看看状态转换关系：

假设有一个线程Thread t

情况1 NEW --> RUNNABLE

• 当调用t.start() 方法时，由 NEW --> RUNNABLE

情况2 RUNNABLE <–> WAITING

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

• 调用 obj.wait()方法时，t 线程从 RUNNABLE --> WAITING
• 调用 obj.notify()， obj.notifyAll() ，t.interrupt() 时
  • 竞争锁成功，t 线程从 WAITING --> RUNNABLE
  • 竞争锁失败，t 线程从 WAITING --> BLOCKED

情况 3 RUNNABLE <–> WAITING

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

情况 4 RUNNABLE <–> WAITING

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

情况 5 RUNNABLE <–> TIMED_WAITING

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

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

情况 6 RUNNABLE <–> TIMED_WAITING

• 当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING
  • 注意是当前线程在t 线程对象的监视器上等待
• 当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的interrupt() 时，当前线程从TIMED_WAITING --> RUNNABLE

情况 7 RUNNABLE <–> TIMED_WAITING

• 当前线程调用 Thread.sleep(long n)，当前线程从 RUNNABLE --> TIMED_WAITING
• 当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE

情况 8 RUNNABLE <–> TIMED_WAITING

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

情况 9 RUNNABLE <–> BLOCKED

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

情况 10 RUNNABLE <–> TERMINATED

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