/**
 * 線程的狀態分析
 * @author aa
 *
 */
public class ThreadState {
    public static void main(String[] args) throws Exception {
        
        /**
         * 新建線程，線程為新建狀態
         * jdk：至今尚未啟動的線程的狀態。 
         * 如果不給線程設置名稱，線程的名稱將會是：Thread-0，Thread-1。。。。。
         */
        ThreadDemo td = new ThreadDemo() ;
        System.out.println(
 
"新建狀態：" + td.getState()) ; // 新建狀態：NEW
        
        /**
         * 可運行狀態：當線程有資格運行，調用start方法，線程首先進入可運行狀態，
         * 可運行狀態，不一定被線程調度程序運行，
         * 簡單來說，調用start方法後，該線程依然是可運行狀態，但未運行，
         * 存放在可運行池中，
         * 線程在運行的過程中，該線程的狀態也是可運行狀態
         * 
         * djk：可運行線程的線程狀態。處於可運行狀態的某一線程正在 Java 虛擬機中運行，
         * 但它可能正在等待操作系統中的其他資源，比如處理器。  
         
 
*/
        td.start() ;
        System.out.println("可運行狀態：" + td.getState()) ; // 可運行狀態：RUNNABLE
        
        /**
         * Main線程休眠100毫秒時，td線程也就調用了waitForTwoSecond()方法，
         * 指定休眠2秒後，再回到可運行狀態
         * 指定等待一定時長時，休眠狀態：TIMED_WAITING
         * jdk：具有指定等待時間的某一等待線程的線程狀態。某一線程因為調用以下帶有指定正等待時間的方法之一而處於定時等待狀態： 
         * 帶有超時值的 Thread.sleep （sleep必須帶值）
         * 帶有超時值的 Object.wait 
         * 帶有超時值的 Thread.join 
         
 
*/
        Thread.sleep(100);
        System.out.println("休眠狀態：" + td.getState()) ; // 具有指定等待時間的某一等待線程的線程狀態。
        
        
        /**
         * 這裏Main線程一共休眠2100毫秒時，td線程調用了waitLong()方法，
         * 該方法調用了wait()，使線程處於一直等待的狀態
         * jdk：某一等待線程的線程狀態。某一線程因為調用下列方法之一而處於等待狀態： 
         * 不帶超時值的 Object.wait 
         * 不帶超時值的 Thread.join 
         */
        Thread.sleep(2000);
        System.out.println("等待狀態：" + td.getState()) ; // 等待狀態：WAITING
        
        td.interrupt() ;
        
        /**
         * 這裏輸出的也可能是終止狀態
         * jdk：受阻塞並且正在等待監視器鎖的某一線程的線程狀態。處於受阻塞狀態的某一線程正在等待監視器鎖，
         * 以便進入一個同步的塊/方法，或者在調用 Object.wait 之後再次進入同步的塊/方法。
         */
        td.notifyWait() ;
        System.out.println("阻塞狀態：" + td.getState()) ;
        
        /**
         * jdk：已終止線程的線程狀態。線程已經結束執行。 
         */
        Thread.sleep(1000);
        System.out.println("終止狀態：" + td.getState()) ;
        
        
        /**
         * 可以簡單歸納為：新建 ， 可運行 ， 運行 ， 阻塞 ， 死亡
         * 
         * Thread.yeild() 讓當前運行的線程回到可運行狀態，讓出時間給其他線程運行，但可能沒用
         * jdk：暫停當前正在執行的線程對象，並執行其他線程。
         */

        
        /**
         * join()的用法
         * jdk：等待該線程終止的時間最長為 millis 毫秒。超時為 0 意味著要一直等下去。 
         * 簡單來說，如下，由於td線程被Main線程所啟動，td線程調用join方法後，
         * 也就是Mian線程要等到td線程運行完畢才會執行join方法後面的代碼，
         * jdk的解析在這裏就是將Main線程加入到了td線程的後面
         * join加參數，在這裏意思就是Main線程需要等待2秒時間再繼續執行join方法後面的代碼，
         */
//        td.join() ;
//        td.join(2000) ;
        System.out.println("線程加入join之後") ;
    }
    
    private static class ThreadDemo extends Thread {
        @Override
        public void run() {
            try {
                // 測試join方法
//                for (int i = 0; i < 5; i++) {
//                    System.out.println(i);
//                    sleep(1000) ;
//                }
                waitForTwoSecond() ;
                waitLong() ;
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        public synchronized void waitForTwoSecond() throws Exception {
            wait(2000) ;
        }
        
        public synchronized void waitLong() throws Exception {
            wait() ;
        }
        
        public synchronized void notifyWait() throws Exception {
            notify() ;
        }
    }
}

線程狀態