JAVA线程究竟有几种状态？

线程状态

线程的状态，在你*度的过程中，你会发现，答案有5种，6种，甚至还有7种的，那么究竟有几种状态？
准确答案就是6种
在编译器JDK1.5以后的环境下，打开Thread进入源码看看：

 * A thread state.  A thread can be in one of the following states:
 * 一个线程，有以下几种状态
 * <ul>
 * <li>{@link #NEW}<br>
 * ①未启动的线程状态   new
 *     A thread that has not yet started is in this state.
 *     </li>
 * <li>{@link #RUNNABLE}<br>
 * ②在jvm中执行的线程状态  runnable
 *     A thread executing in the Java virtual machine is in this state.
 *     </li>
 * <li>{@link #BLOCKED}<br>
 * ③一个线程被阻塞，等待监控锁的线程状态  blocked
 *     A thread that is blocked waiting for a monitor lock
 *     is in this state.
 *     </li>
 * <li>{@link #WAITING}<br>
 * 	④一个线程  为了永久等待另一个线程特定的操作的线程状态  waiting
 * 翻译后通顺点：无限等待另一个线程的线程执行特定的操作处于此状态
 *     A thread that is waiting indefinitely for another thread to
 *     perform a particular action is in this state.
 *     </li>
 * <li>{@link #TIMED_WAITING}<br>
 *   ⑤ 一个线程  等待另一个线程执行特定的操作的等待时间内的线程状态   timed_waiting
 *     正在等待另一个线程执行某个操作的线程在指定的等待时间内处于这种状态
 *     A thread that is waiting for another thread to perform an action
 *     for up to a specified waiting time is in this state.
 *     </li>
 * <li>{@link #TERMINATED}<br>
 * ⑥一个线程已经被退出的状态   终止  terminated
 *     A thread that has exited is in this state.
 *     </li>
 * </ul>
 *
 * <p>
 * 在给定的时间点上，线程只能处于一种状态。这些状态是虚拟机状态，不反映任何操作系统线程状态
 * A thread can be in only one state at a given point in time.
 * These states are virtual machine states which do not reflect
 * any operating system thread states.
 *
 * @since   1.5   
 * @see #getState
 */

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线程的不同状态

摘要：在Java多线程编程中，了解线程的不同状态对于实现高效可靠的并发程序至关重要。本文将深入研究Java线程的不同状态，包括线程的生命周期、状态转换和相关的API。我们将探索线程的创建、运行、阻塞和终止等各个阶段，并介绍如何合理地利用线程状态来优化并发程序。

1. 引言

Java的多线程机制为我们提供了一种有效的方式来并发执行任务，提高程序的性能。理解线程的不同状态对于正确地管理和控制线程非常重要。Java线程在不同的阶段具有不同的状态，本文将详细讨论这些状态。

2. 线程的生命周期

在Java中，线程可以存在于不同的状态，这些状态共同构成了线程的生命周期。Java线程的生命周期包括以下几个阶段：

2.1 新建状态（New）：线程对象被创建，但尚未开始执行。

2.2 运行状态（Runnable）：线程正在执行或准备开始执行。在运行状态中，线程可以进一步分为以下几种状态：

• 就绪状态（Ready）：线程处于就绪状态，等待获取CPU时间片段以执行。
• 运行状态（Running）：线程正在执行任务。

2.3 阻塞状态（Blocked）：线程暂时停止执行，等待某个条件的满足（如等待I/O操作完成）。

2.4 等待状态（Waiting）：线程暂时停止执行，等待其他线程的通知。

2.5 计时等待状态（Timed Waiting）：线程暂时停止执行，等待其他线程的通知，但有一个超时时间限制。

2.6 终止状态（Terminated）：线程执行完毕，或者因为异常情况而终止。

3. 线程状态转换

线程在不同状态之间转换的规则是由Java虚拟机(JVM)自动管理的。下面是一些常见的状态转换情况：

3.1 新建状态到就绪状态：通过调用线程对象的start()方法将线程从新建状态转换到就绪状态。

3.2 就绪状态到运行状态：当线程获取到CPU时间片段后，从就绪状态转换到运行状态。

3.3 运行状态到阻塞状态：当线程需要等待某些条件满足时（如等待I/O操作完成），它将进入阻塞状态。

3.4 运行状态到等待状态：线程可以通过调用wait()方法进入等待状态，等待其他线程的通知。

3.5 运行状态到计时等待状态：线程可以通过调用sleep()方法或join()方法中带有超时参数的重载版本，使线程进入计时等待状态，等待一定时间后再继续执行。

3.6 阻塞状态到就绪状态：当线程等待的条件得到满足后，它将从阻塞状态转换为就绪状态，等待获取CPU时间片段以执行。

3.7 等待状态到就绪状态：当等待的条件满足后，其他线程通过调用notify()或notifyAll()方法来唤醒等待中的线程，使其转换为就绪状态。

3.8 等待状态到阻塞状态：线程在等待状态下，可能被其他线程中断，使其转换为阻塞状态。

3.9 运行状态到终止状态：当线程的任务执行成功完成或出现异常而终止时，线程将从运行状态转换为终止状态。

4. 线程状态的示例代码

下面是一个简单的示例代码，演示了线程在不同状态之间的转换：

public class ThreadStateExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("子线程执行...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("新建状态：" + thread.getState());

        thread.start();
        Thread.sleep(200);

        System.out.println("就绪状态：" + thread.getState());
        Thread.sleep(500);

        System.out.println("运行状态：" + thread.getState());
        Thread.sleep(1000);

        System.out.println("运行状态：" + thread.getState());
        Thread.sleep(2000);

        System.out.println("终止状态：" + thread.getState());
    }
}

运行以上代码，可以观察到线程在不同状态之间的转换。

5. 线程状态的相关API

Java提供了一些与线程状态相关的方法和类，用于管理和查询线程的状态：

5.1 getState()方法：可以获取线程的当前状态。

5.2 Thread.State枚举类：提供了线程的几种状态，包括NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED。

5.3 Thread.sleep()方法：可以使线程进入计时等待状态，指定一定的休眠时间。

5.4 Object.wait()方法：可以使线程进入等待状态，直到其他线程调用了相同对象上的notify()或notifyAll()方法。

5.5 Thread.join()方法：可以使当前线程等待其他线程执行完毕后再继续执行。

**