此片文章主要總結(jié)的是Thread類及相關(guān)的基礎(chǔ)概念和API，首先需要厘清線程調(diào)度中的幾個基本概念：

一、線程調(diào)度的基本方法

1、調(diào)整線程優(yōu)先級：

Java線程有優(yōu)先級，優(yōu)先級高的線程會獲得較多的運行機會。Java線程的優(yōu)先級用整數(shù)表示，取值范圍是1~10，Thread類有以下三個靜態(tài)常量：

static int MAX_PRIORITY    //線程可以具有的最高優(yōu)先級，取值為10。

static int MIN_PRIORITY    //線程可以具有的最低優(yōu)先級，取值為1。

static int NORM_PRIORITY  //分配給線程的默認(rèn)優(yōu)先級，取值為5。

Thread類的setPriority()和getPriority()方法分別用來設(shè)置和獲取線程的優(yōu)先級。每個線程都有默認(rèn)的優(yōu)先級。主線程的默認(rèn)優(yōu)先級為Thread.NORM_PRIORITY。線程的優(yōu)先級有繼承關(guān)系，比如A線程中創(chuàng)建了B線程，那么B將和A具有相同的優(yōu)先級。JVM提供了10個線程優(yōu)先級，但與常見的操作系統(tǒng)都不能很好的映射。如果希望程序能移植到各個操作系統(tǒng)中，應(yīng)該僅僅使用Thread類有以下三個靜態(tài)常量作為優(yōu)先級，這樣能保證同樣的優(yōu)先級采用了同樣的調(diào)度方式。

2、線程睡眠：

Thread.sleep(long millis)方法，使線程轉(zhuǎn)到阻塞狀態(tài)。millis參數(shù)設(shè)定睡眠的時間，以毫秒為單位。當(dāng)睡眠結(jié)束后，就轉(zhuǎn)為就緒（Runnable）狀態(tài)。sleep()平臺移植性好。

3、線程等待：

Object類中的wait()方法，導(dǎo)致當(dāng)前的線程等待，直到其他線程調(diào)用此對象的notify()方法或 notifyAll() 喚醒方法。這個兩個喚醒方法也是Object類中的方法，行為等價于調(diào)用 wait(0) 一樣。

4、線程讓步：

Thread.yield()方法，暫停當(dāng)前正在執(zhí)行的線程對象，把執(zhí)行機會讓給相同或者更高優(yōu)先級的線程。

5、線程加入：

join()方法，等待其他線程終止。在當(dāng)前線程中調(diào)用另一個線程的join()方法，則當(dāng)前線程轉(zhuǎn)入阻塞狀態(tài)，直到另一個進(jìn)程運行結(jié)束，當(dāng)前線程再由阻塞轉(zhuǎn)為就緒狀態(tài)。

6、線程喚醒：

Object類中的notify()方法，喚醒在此對象監(jiān)視器上等待的單個線程。如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程。選擇是任意性的，并在對實現(xiàn)做出決定時發(fā)生。線程通過調(diào)用其中一個 wait方法，在對象的監(jiān)視器上等待。 直到當(dāng)前的線程放棄此對象上的鎖定，才能繼續(xù)執(zhí)行被喚醒的線程。被喚醒的線程將以常規(guī)方式與在該對象上主動同步的其他所有線程進(jìn)行競爭；例如，喚醒的線程在作為鎖定此對象的下一個線程方面沒有可靠的特權(quán)或劣勢。類似的方法還有一個notifyAll()，喚醒在此對象監(jiān)視器上等待的所有線程。

注意：Thread中suspend()和resume()兩個方法在JDK1.5中已經(jīng)廢除，不再介紹。因為有死鎖傾向。

二、常用函數(shù)

①sleep(long millis): 在指定的毫秒數(shù)內(nèi)讓當(dāng)前正在執(zhí)行的線程休眠（暫停執(zhí)行）
②join():指等待t線程終止。join是Thread類的一個方法，啟動線程后直接調(diào)用，即join()的作用是：“等待該線程終止”，這里需要理解的就是該線程是指的主線程等待子線程的終止。也就是在子線程調(diào)用了join()方法后面的代碼，只有等到子線程結(jié)束了才能執(zhí)行。

Thread t = new AThread();
t.start();
t.join(); 

為什么要用join()方法?在很多情況下，主線程生成并起動了子線程，如果子線程里要進(jìn)行大量的耗時的運算，主線程往往將于子線程之前結(jié)束，但是如果主線程處理完其他的事務(wù)后，需要用到子線程的處理結(jié)果，也就是主線程需要等待子線程執(zhí)行完成之后再結(jié)束，這個時候就要用到join()方法了。

public class Main2 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"主線程運行開始!");
        Thread1 mTh1=new Thread1("A");
        Thread1 mTh2=new Thread1("B");
        mTh1.start();
        mTh2.start();
        try {
            mTh1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            mTh2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+ "主線程運行結(jié)束!");
    }
}
class Thread1 extends Thread{
    private String name;
    public Thread1(String name) {
        super(name);
        this.name=name;
    }
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 線程運行開始!");
        for (int i = 0; i < 5; i++) {
            System.out.println("子線程"+name + "運行 : " + i);
            try {
                sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 線程運行結(jié)束!");
    }
}

main主線程運行開始!
A 線程運行開始!
B 線程運行開始!
子線程A運行 : 0
子線程B運行 : 0
子線程A運行 : 1
子線程A運行 : 2
子線程A運行 : 3
子線程A運行 : 4
A 線程運行結(jié)束!
子線程B運行 : 1
子線程B運行 : 2
子線程B運行 : 3
子線程B運行 : 4
B 線程運行結(jié)束!
main主線程運行結(jié)束!

③yield():暫停當(dāng)前正在執(zhí)行的線程對象，并執(zhí)行其他線程。

Thread.yield()方法作用是：暫停當(dāng)前正在執(zhí)行的線程對象，并執(zhí)行其他線程。yield()應(yīng)該做的是讓當(dāng)前運行線程回到可運行狀態(tài)，以允許具有相同優(yōu)先級的其他線程獲得運行機會。因此，使用yield()的目的是讓相同優(yōu)先級的線程之間能適當(dāng)?shù)妮嗈D(zhuǎn)執(zhí)行。但是，實際中無法保證yield()達(dá)到讓步目的，因為讓步的線程還有可能被線程調(diào)度程序再次選中。

結(jié)論：yield()從未導(dǎo)致線程轉(zhuǎn)到等待/睡眠/阻塞狀態(tài)。在大多數(shù)情況下，yield()將導(dǎo)致線程從運行狀態(tài)轉(zhuǎn)到可運行狀態(tài)，但有可能沒有效果（注意線程的生命周期）。

public class Main2 {
    public static void main(String[] args) {
        ThreadYield yt1 = new ThreadYield("張三");
        ThreadYield yt2 = new ThreadYield("李四");
        yt1.start();
        yt2.start();
    }
}
class ThreadYield extends Thread{
    public ThreadYield(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 1; i <= 50; i++) {
            System.out.println("" + this.getName() + "-----" + i);
            // 當(dāng)i為30時，該線程就會把CPU時間讓掉，讓其他或者自己的線程執(zhí)行（也就是誰先搶到誰執(zhí)行）
            if (i ==30) {
                this.yield();
            }
        }
    }
}

運行結(jié)果：
第一種情況：李四（線程）當(dāng)執(zhí)行到30時會CPU時間讓掉，這時張三（線程）搶到CPU時間并執(zhí)行。
第二種情況：李四（線程）當(dāng)執(zhí)行到30時會CPU時間讓掉，這時李四（線程）搶到CPU時間并執(zhí)行。

④setPriority(): 更改線程的優(yōu)先級。

MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10

用法：

Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

⑤interrupt():不要以為它是中斷某個線程！它只是線線程發(fā)送一個中斷信號，讓線程在無限等待時（如死鎖時）能拋出拋出，從而結(jié)束線程，但是如果你吃掉了這個異常，那么這個線程還是不會中斷的！

⑥wait()：Obj.wait()，與Obj.notify()必須要與synchronized(Obj)一起使用，也就是wait,與notify是針對已經(jīng)獲取了Obj鎖進(jìn)行操作，從語法角度來說就是Obj.wait(),Obj.notify必須在synchronized(Obj){...}語句塊內(nèi)。從功能上來說wait就是說線程在獲取對象鎖后，主動釋放對象鎖，同時本線程休眠。直到有其它線程調(diào)用對象的notify()喚醒該線程，才能繼續(xù)獲取對象鎖，并繼續(xù)執(zhí)行。相應(yīng)的notify()就是對對象鎖的喚醒操作。但有一點需要注意的是notify()調(diào)用后，并不是馬上就釋放對象鎖的，而是在相應(yīng)的synchronized(){}語句塊執(zhí)行結(jié)束，自動釋放鎖后，JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續(xù)執(zhí)行。這樣就提供了在線程間同步、喚醒的操作。Thread.sleep()與Object.wait()二者都可以暫停當(dāng)前線程，釋放CPU控制權(quán)，主要的區(qū)別在于Object.wait()在釋放CPU同時，釋放了對象鎖的控制。

單單在概念上理解清楚了還不夠，需要在實際的例子中進(jìn)行測試才能更好的理解。對Object.wait()，Object.notify()的應(yīng)用最經(jīng)典的例子，應(yīng)該是三線程打印ABC的問題了吧，這是一道比較經(jīng)典的面試題，題目要求如下：建立三個線程，A線程打印10次A，B線程打印10次B,C線程打印10次C，要求線程同時運行，交替打印10次ABC。這個問題用Object的wait()，notify()就可以很方便的解決。代碼如下：

public class MyThreadPrinter2 implements Runnable {     
        
    private String name;     
    private Object prev;     
    private Object self;     
    
    private MyThreadPrinter2(String name, Object prev, Object self) {     
        this.name = name;     
        this.prev = prev;     
        this.self = self;     
    }     
    
    @Override    
    public void run() {     
        int count = 10;     
        while (count > 0) {     
            synchronized (prev) {     
                synchronized (self) {     
                    System.out.print(name);     
                    count--;    
                      
                    self.notify();     
                }     
                try {     
                    prev.wait();     
                } catch (InterruptedException e) {     
                    e.printStackTrace();     
                }     
            }     
        }     
    }     
    
    public static void main(String[] args) throws Exception {     
        Object a = new Object();     
        Object b = new Object();     
        Object c = new Object();     
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);     
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);     
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);     
                  
        new Thread(pa).start();  
        Thread.sleep(100);  //確保按順序A、B、C執(zhí)行  
        new Thread(pb).start();  
        Thread.sleep(100);    
        new Thread(pc).start();     
        Thread.sleep(100);    
        }     
}   

先來解釋一下其整體思路，從大的方向上來講，該問題為三線程間的同步喚醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環(huán)執(zhí)行三個線程。為了控制線程執(zhí)行的順序，那么就必須要確定喚醒、等待的順序，所以每一個線程必須同時持有兩個對象鎖，才能繼續(xù)執(zhí)行。一個對象鎖是prev，就是前一個線程所持有的對象鎖。還有一個就是自身對象鎖。主要的思想就是，為了控制執(zhí)行的順序，必須要先持有prev鎖，也就前一個線程要釋放自身對象鎖，再去申請自身對象鎖，兩者兼?zhèn)鋾r打印，之后首先調(diào)用self.notify()釋放自身對象鎖，喚醒下一個等待線程，再調(diào)用prev.wait()釋放prev對象鎖，終止當(dāng)前線程，等待循環(huán)結(jié)束后再次被喚醒。運行上述代碼，可以發(fā)現(xiàn)三個線程循環(huán)打印ABC，共10次。程序運行的主要過程就是A線程最先運行，持有C,A對象鎖，后釋放A,C鎖，喚醒B。線程B等待A鎖，再申請B鎖，后打印B，再釋放B，A鎖，喚醒C，線程C等待B鎖，再申請C鎖，后打印C，再釋放C,B鎖，喚醒A。看起來似乎沒什么問題，但如果你仔細(xì)想一下，就會發(fā)現(xiàn)有問題，就是初始條件，三個線程按照A,B,C的順序來啟動，按照前面的思考，A喚醒B，B喚醒C，C再喚醒A。但是這種假設(shè)依賴于JVM中線程調(diào)度、執(zhí)行的順序。

三、深入考察及疑難點

1、啟動一個線程是調(diào)用 run() 還是 start() 方法？start() 和 run() 方法有什么區(qū)別

相當(dāng)于玩游戲機，只有一個游戲機（cpu），可是有很多人要玩，于是，start是排隊！等CPU選中你就是輪到你，你就run（），當(dāng)CPU的運行的時間片執(zhí)行完，這個線程就繼續(xù)排隊，等待下一次的run（）。調(diào)用start（）后，線程會被放到等待隊列，等待CPU調(diào)度，并不一定要馬上開始執(zhí)行，只是將這個線程置于可動行狀態(tài)。然后通過JVM，線程Thread會調(diào)用run（）方法，執(zhí)行本線程的線程體。先調(diào)用start后調(diào)用run，這么麻煩，為了不直接調(diào)用run？就是為了實現(xiàn)多線程的優(yōu)點，沒這個start不行。

（1）.start（）方法來啟動線程，真正實現(xiàn)了多線程運行。這時無需等待run方法體代碼執(zhí)行完畢，可以直接繼續(xù)執(zhí)行下面的代碼；通過調(diào)用Thread類的start()方法來啟動一個線程， 這時此線程是處于就緒狀態(tài)， 并沒有運行。 然后通過此Thread類調(diào)用方法run()來完成其運行操作的， 這里方法run()稱為線程體，它包含了要執(zhí)行的這個線程的內(nèi)容， Run方法運行結(jié)束， 此線程終止。然后CPU再調(diào)度其它線程。

（2）.run（）方法當(dāng)作普通方法的方式調(diào)用。程序還是要順序執(zhí)行，要等待run方法體執(zhí)行完畢后，才可繼續(xù)執(zhí)行下面的代碼； 程序中只有主線程——這一個線程， 其程序執(zhí)行路徑還是只有一條， 這樣就沒有達(dá)到寫線程的目的。
記?。憾嗑€程就是分時利用CPU，宏觀上讓所有線程一起執(zhí)行 ，也叫并發(fā)

start() :它的作用是啟動一個新線程，新線程處于就緒狀態(tài)，拿到cpu執(zhí)行權(quán)就會執(zhí)行相應(yīng)的run()方法。start()不能被重復(fù)調(diào)用。
run(): run()就和普通的成員方法一樣，可以被重復(fù)調(diào)用。單獨調(diào)用run()的話，會在當(dāng)前線程中執(zhí)行run()，而并不會啟動新線程?。槭裁床恢苯诱{(diào)用run方法的原因也在此。）

2、sleep() 方法和對象的 wait() 方法都可以讓線程暫停執(zhí)行，它們有什么區(qū)別？

sleep（）方法
sleep()使當(dāng)前線程進(jìn)入停滯狀態(tài)（阻塞當(dāng)前線程），讓出CUP的使用、目的是不讓當(dāng)前線程獨自霸占該進(jìn)程所獲的CPU資源，以留一定時間給其他線程執(zhí)行的機會;sleep()是Thread類的Static(靜態(tài))的方法；因此他不能改變對象的機鎖，所以當(dāng)在一個Synchronized塊中調(diào)用Sleep()方法是，線程雖然休眠了，但是對象的機鎖并木有被釋放，其他線程無法訪問這個對象（即使睡著也持有對象鎖）。在sleep()休眠時間期滿后，該線程不一定會立即執(zhí)行，這是因為其它線程可能正在運行而且沒有被調(diào)度為放棄執(zhí)行，除非此線程具有更高的優(yōu)先級。

wait（）方法
wait()方法是Object類里的方法；當(dāng)一個線程執(zhí)行到wait()方法時，它就進(jìn)入到一個和該對象相關(guān)的等待池中，同時失去（釋放）了對象的機鎖（暫時失去機鎖，wait(long timeout)超時時間到后還需要返還對象鎖）；其他線程可以訪問；wait()使用notify或者notifyAlll或者指定睡眠時間來喚醒當(dāng)前等待池中的線程。wiat()必須放在synchronized block中，否則會在program runtime時扔出”java.lang.IllegalMonitorStateException“異常。
共同點：

1. 他們都是在多線程的環(huán)境下，都可以在程序的調(diào)用處阻塞指定的毫秒數(shù)，并返回。

2. wait()和sleep()都可以通過interrupt()方法 打斷線程的暫停狀態(tài)，從而使線程立刻拋出InterruptedException。

   如果線程A希望立即結(jié)束線程B，則可以對線程B對應(yīng)的Thread實例調(diào)用interrupt方法。如果此刻線程B正在wait/sleep /join，則線程B會立刻拋出InterruptedException，在catch() {} 中直接return即可安全地結(jié)束線程。 需要注意的是，InterruptedException是線程自己從內(nèi)部拋出的，并不是interrupt()方法拋出的。對某一線程調(diào)用 interrupt()時，如果該線程正在執(zhí)行普通的代碼，那么該線程根本就不會拋出InterruptedException。但是，一旦該線程進(jìn)入到 wait()/sleep()/join()后，就會立刻拋出InterruptedException 。

不同點：

1. Thread類的方法：sleep(),yield()等。Object的方法：wait()和notify()等

2. 每個對象都有一個鎖來控制同步訪問。Synchronized關(guān)鍵字可以和對象的鎖交互，來實現(xiàn)線程的同步。sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。

3. wait，notify和notifyAll只能在同步控制方法或者同步控制塊里面使用，而sleep可以在任何地方使用

4. sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常

所以sleep()和wait()方法的最大區(qū)別是：sleep()睡眠時，保持對象鎖，仍然占有該鎖；而wait()睡眠時，釋放對象鎖。但是wait()和sleep()都可以通過interrupt()方法打斷線程的暫停狀態(tài)，從而使線程立刻拋出InterruptedException（但不建議使用該方法）。

3、yield方法有什么作用？sleep() 方法和 yield()方法有什么區(qū)別?

sleep()和yield()的區(qū)別:sleep()使當(dāng)前線程進(jìn)入停滯狀態(tài)，所以執(zhí)行sleep()的線程在指定的時間內(nèi)肯定不會被執(zhí)行；yield()只是使當(dāng)前線程重新回到可執(zhí)行狀態(tài)，所以執(zhí)行yield()的線程有可能在進(jìn)入到可執(zhí)行狀態(tài)后馬上又被執(zhí)行。

sleep 方法使當(dāng)前運行中的線程睡眼一段時間，進(jìn)入不可運行狀態(tài)，這段時間的長短是由程序設(shè)定的，yield 方法使當(dāng)前線程讓出 CPU 占有權(quán)，但讓出的時間是不可設(shè)定的。實際上，yield()方法對應(yīng)了如下操作：先檢測當(dāng)前是否有相同優(yōu)先級的線程處于同可運行狀態(tài)，如有，則把 CPU 的占有權(quán)交給此線程，否則，繼續(xù)運行原來的線程。所以yield()方法稱為“退讓”，它把運行機會讓給了同等優(yōu)先級的其他線程

另外，sleep 方法允許較低優(yōu)先級的線程獲得運行機會，但 yield() 方法執(zhí)行時，當(dāng)前線程仍處在可運行狀態(tài)，所以，不可能讓出較低優(yōu)先級的線程些時獲得 CPU 占有權(quán)。在一個運行系統(tǒng)中，如果較高優(yōu)先級的線程沒有調(diào)用 sleep 方法，又沒有受到 I\O 阻塞，那么，較低優(yōu)先級線程只能等待所有較高優(yōu)先級的線程運行結(jié)束，才有機會運行。

4、Java 中如何停止一個線程？**

停止一個線程意味著在任務(wù)處理完任務(wù)之前停掉正在做的操作，也就是放棄當(dāng)前的操作。停止一個線程可以用Thread.stop()方法，但最好不要用它。雖然它確實可以停止一個正在運行的線程，但是這個方法是不安全的，而且是已被廢棄的方法。在java中有以下3種方法可以終止正在運行的線程：
1.使用退出標(biāo)志，使線程正常退出，也就是當(dāng)run方法完成后線程終止。
2.使用stop方法強行終止，但是不推薦這個方法，因為stop和suspend及resume一樣都是過期作廢的方法。
3.使用interrupt方法中斷線程。具體案例和api可以參考文章《java多線程之——interrupt深入研究》。

5、stop()和 suspend()方法為何不推薦使用?

Stop()方法作為一種粗暴的線程終止行為，在線程終止之前沒有對其做任何的清除操作，因此具有固有的不安全性。 用Thread.stop()方法來終止線程將會釋放該線程對象已經(jīng)鎖定的所有監(jiān)視器。如果以前受這些監(jiān)視器保護(hù)的任何對象都處于不連貫狀態(tài)，那么損壞的對象對其他線程可見，這有可能導(dǎo)致不安全的操作。 由于上述原因，因此不應(yīng)該使用stop()方法，而應(yīng)該在自己的Thread類中置入一個標(biāo)志，用于控制目標(biāo)線程是活動還是停止。如果該標(biāo)志指示它要停止運行，可使其結(jié)束run（）方法。如果目標(biāo)線程等待很長時間，則應(yīng)使用interrupt()方法來中斷該等待。

suspend()方法 該方法已經(jīng)遭到反對，因為它具有固有的死鎖傾向。調(diào)用suspend（）方法的時候，目標(biāo)線程會停下來。如果目標(biāo)線程掛起時在保護(hù)關(guān)鍵系統(tǒng)資源的監(jiān)視器上保持有鎖，則在目標(biāo)線程重新開始以前，其他線程都不能訪問該資源。除非被掛起的線程恢復(fù)運行。對任何其他線程來說，如果想恢復(fù)目標(biāo)線程，同時又試圖使用任何一個鎖定的資源，就會造成死鎖。由于上述原因，因此不應(yīng)該使用suspend（）方法，而應(yīng)在自己的thread類中置入一個標(biāo)志，用于控制線程是活動還是掛起。如果標(biāo)志指出線程應(yīng)該掛起，那么用wait（）方法命令其進(jìn)入等待狀態(tài)。如果標(biāo)志指出線程應(yīng)當(dāng)恢復(fù)，那么用notify()方法重新啟動線程。

6、如何在兩個線程間共享數(shù)據(jù)?

通過在線程之間共享對象就可以了，然后通過wait/notify/notifyAll、await/signal/signalAll進(jìn)行喚起和等待，比方說阻塞隊列BlockingQueue就是為線程之間共享數(shù)據(jù)而設(shè)計的。

7、強制啟動一個線程？

• 實現(xiàn)Runnable接口優(yōu)勢：
  1）適合多個相同的程序代碼的線程去處理同一個資源。
  2）可以避免java中的單繼承的限制。
  3）增加程序的健壯性，代碼可以被多個線程共享，代碼和數(shù)據(jù)獨立。
• 繼承Thread類優(yōu)勢：
  1）可以將線程類抽象出來，當(dāng)需要使用抽象工廠模式設(shè)計時。
  2）多線程同步
• 在函數(shù)體使用
  1）無需繼承thread或者實現(xiàn)Runnable，縮小作用域。

8、如何讓正在運行的線程暫停一段時間

1、sleep()方法（休眠）是線程類（Thread）的靜態(tài)方法，調(diào)用此方法會讓當(dāng)前線程暫停執(zhí)行指定的時間，將執(zhí)行機會（CPU）讓給其他線程，但是對象的鎖依然保持，因此休眠時間結(jié)束后會自動恢復(fù)（線程回到就緒狀態(tài)，請參考第66題中的線程狀態(tài)轉(zhuǎn)換圖）。
2、wait()是Object類的方法，調(diào)用對象的wait()方法導(dǎo)致當(dāng)前線程放棄對象的鎖（線程暫停執(zhí)行），進(jìn)入對象的等待池（wait pool），只有調(diào)用對象的notify()方法（或notifyAll()方法）時才能喚醒等待池中的線程進(jìn)入等鎖池（lockpool），如果線程重新獲得對象的鎖就可以進(jìn)入就緒狀態(tài)

9、什么是線程組，為什么在Java中不推薦使用？

ThreadGroup是一個類, 它的目的是提供關(guān)于線程組的信息.
ThreadGroupAPI比較薄弱, 它并沒有為Thread提供了更多的功能. 它主要有兩個功能: 一是獲取線程組中處于活躍狀態(tài)線程的列表; 二是甚至為線程設(shè)置未捕獲異常處理器(uncaught exception handler) . 但在java 1.5中Thread類也添加了setUncaughtExceptionHandler(UncaughtExceptionHandler eh)方法, 所以ThreadGroup是已經(jīng)過時的, 不建議使用.

10、你是如何調(diào)用 wait（方法的）？使用 if 塊還是循環(huán)？為什么

wait() 方法應(yīng)該在循環(huán)調(diào)用，因為當(dāng)線程獲取到 CPU 開始執(zhí)行的時候，其他條件可能還沒有滿足，所以在處理前，循環(huán)檢測條件是否滿足會更好。