public enum State {
    /**
     * 尚未啟動的線程的線程狀態(tài) （沒有start）
     */
    NEW,

    /**
     * 可運行線程的線程狀態(tài)，是可以運行的線程狀態(tài)（并不是在運行）
     * 這個狀態(tài)在Java虛擬機中進行，但它可能等待來自操作系統(tǒng)的其他資源，比如CPU。
     * 內(nèi)部包含了兩個狀態(tài) 【RUNNING】,【READY】這兩個狀態(tài)是可以互相流轉(zhuǎn)的
     * 調(diào)用了start后線程就處于 READY 狀態(tài) ，等待操作系統(tǒng)分配CPU時間片，分配后進入 RUNNING 狀態(tài)。
     * 當(dāng)調(diào)用 yield() 方法后，只是謙讓的允許當(dāng)前線程讓出 CPU ，但是不一定讓，由操作系統(tǒng)決定，如果讓      * 了當(dāng)前線程就會進入 READY 狀態(tài)，等待系統(tǒng)分配CPU時間片再次進入 RUNNING 狀態(tài)。
     */
    RUNNABLE,

    /**
     * 阻塞狀態(tài)。
     * 線程阻塞，等待監(jiān)視器鎖的狀態(tài)，獲取監(jiān)視器鎖后會進入 RUNNABLE  狀態(tài)
     * 當(dāng)發(fā)生線程鎖競爭狀態(tài)下，沒有獲取到鎖的線程會被掛起進入阻塞狀態(tài)，比如synchronized鎖。
     */
    BLOCKED,

    /**
     * 等待線程的線程狀態(tài)
     * 線程調(diào)用以下方法會處于等待狀態(tài)：Object.wait()不超時、Thread.join()不超時等方法
     * 一個處于等待狀態(tài)的線程正在等待另一個線程執(zhí)行特定動作，例如：
     * 一個線程調(diào)用了Object.wait()方法在一個對象上正在等待另一個線程調(diào)用Object.nofify()或者
     * Object.nofifyAll()方法開啟那個對象
     * 一個調(diào)用了Thread.join()方法的線程正在等待指定線程終止
     */
    WAITING,

    /**
     * 具有指定等待時間的等待線程的線程狀態(tài)，調(diào)用一下方法會處于這個狀態(tài)： Object.wait() 超時、          * Thread.join()超時 Thread.sleep(long) 等方法 
     */
    TIMED_WAITING,

    /**
     * 已終止線程的線程狀態(tài)
     * 線程執(zhí)行完畢或者發(fā)生異常終止執(zhí)行
     */
    TERMINATED;
}

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狀態(tài)
            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();
                    }
                }
            }
        }
    }
}

public synchronized void start() {
    . . .
    boolean started = false;
    try { 
        // 調(diào)用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 */
        }
    }
}

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;
      // 先創(chuàng)建一個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(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
// 調(diào)用os(操作系統(tǒng))創(chuàng)建個線程
  os::create_thread(this, thr_type, stack_sz);
  _safepoint_visible = false;
   . . .
}

// 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:啟動之后設(shè)置線程的狀態(tài)為 可運行狀態(tài) RUNNABLE
      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
                                          java_lang_Thread::RUNNABLE);
    }
    // 借助操作系統(tǒng)啟動線程
    os::start_thread(thread);
  }
}

thread.cpp interrupt 借用操作系統(tǒng)。直接通過系統(tǒng)調(diào)用 interrupt
void Thread::interrupt(Thread* thread) {
  trace("interrupt", thread);
  debug_only(check_for_dangling_thread_pointer(thread);)
  // tips: 調(diào)用操作系統(tǒng)的interrupt方法
  os::interrupt(thread);
}