JAVA线程一共有几种状态

 * A thread state.  A thread can be in one of the following states:     * 一个线程，有以下几种状态     * 
     * 
{@link #NEW}
     * ①未启动的线程状态   new     *     A thread that has not yet started is in this state.     *     
     * 
{@link #RUNNABLE}
     * ②在jvm中执行的线程状态  runnable     *     A thread executing in the Java virtual machine is in this state.     *     
     * 
{@link #BLOCKED}
     * ③一个线程被阻塞，等待监控锁的线程状态  blocked     *     A thread that is blocked waiting for a monitor lock     *     is in this state.     *     
     * 
{@link #WAITING}
     *   ④一个线程  为了永久等待另一个线程特定的操作的线程状态  waiting     * 翻译后通顺点：无限等待另一个线程的线程执行特定的操作处于此状态     *     A thread that is waiting indefinitely for another thread to     *     perform a particular action is in this state.     *     
     * 
{@link #TIMED_WAITING}
     *   ⑤ 一个线程  等待另一个线程执行特定的操作的等待时间内的线程状态   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.     *     
     * 
{@link #TERMINATED}
     * ⑥一个线程已经被退出的状态   终止  terminated     *     A thread that has exited is in this state.     *     
     * 
     *     * 
     * 在给定的时间点上，线程只能处于一种状态。这些状态是虚拟机状态，不反映任何操作系统线程状态     * 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:         * 
         *   
{@link Object#wait() Object.wait} with no timeout         *   
{@link #join() Thread.join} with no timeout         *   
{@link LockSupport#park() LockSupport.park}         * 
         *         * 
A thread in the waiting state is waiting for another thread to         * perform a particular action.         *         * For example, a thread that has called Object.wait()         * on an object is waiting for another thread to call         * Object.notify() or Object.notifyAll() on         * that object. A thread that has called Thread.join()         * 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:         * 
         *   
{@link #sleep Thread.sleep}         *   
{@link Object#wait(long) Object.wait} with timeout         *   
{@link #join(long) Thread.join} with timeout         *   
{@link LockSupport#parkNanos LockSupport.parkNanos}         *   
{@link LockSupport#parkUntil LockSupport.parkUntil}         * 
         */        TIMED_WAITING,
        /**         * Thread state for a terminated thread.         * The thread has completed execution.         */        TERMINATED;    }```