①原理不同。

sleep()方法是Thread類的靜態方法，是執行緒用來控制自身流程的，它會使此執行緒暫停執行一段時間，而把執行機會讓給其他執行緒，等到計時時間一到，此執行緒會自動甦醒。而wait()方法是Object類的方法，用於執行緒間的通訊，這個方法會使當前擁有該物件鎖的程序等待，直到其他執行緒用呼叫notify()或notifyAll()時才甦醒過來，開發人員也可以給它指定一個時間使其自動醒來。

②對鎖的處理機制不同。

呼叫sleep()方法並不會釋放鎖。而wait()方法則不同，執行緒會釋放掉它所佔用的鎖。

wait()方法必須放在同步控制方法或者同步語句塊中使用，而sleep方法則可以放在任何地方使用。

舉一個通俗的例子:sleep,wait

執行緒sleep就好比你去火車站視窗買票，你交完錢之後，你需要在那兒等著售票員查詢並且出完票，最終把票交到你手上，你拿到票之後才會離開，期間在後面排隊的人，是不能直接越過你找售票員買票的，只有待你離開後，你後面的人才能接著買票！

執行緒wait就好比你去肯德基排隊買套餐，你點完餐之後，服務員會讓你到旁邊等待取餐，緊接著會處理你後面的人點餐需求，待你的套餐做好之後，會有人通知你取餐！

sleep休眠，wait等待，sleep只能被interrupt打斷，而wait只能被notily喚醒，wait是cpu級別的，cpu放棄當前執行緒，sleep只是休眠，sleep只是暫時休眠，當前執行緒還持有當前的鎖，而wait是放棄當前執行緒

Java中的多執行緒是一種搶佔式的機制而不是分時機制。執行緒主要有以下幾種狀態：可執行，執行，阻塞，死亡。搶佔式機制指的是有多個執行緒處於可執行狀態，但是隻有一個執行緒在執行。

當有多個執行緒訪問共享資料的時候，就需要對執行緒進行同步。執行緒中的幾個主要方法的比較：

Thread類的方法：sleep(),yield()等

Object的方法：wait()和notify()等

每個物件都有一個機鎖來控制同步訪問。Synchronized關鍵字可以和物件的機鎖互動，來實現執行緒的同步。

由於sleep()方法是Thread類的方法，因此它不能改變物件的機鎖。所以當在一個Synchronized方法中呼叫sleep（）時，執行緒雖然休眠了，但是物件的機鎖沒有被釋放，其他執行緒仍然無法訪問這個物件。而wait()方法則會線上程休眠的同時釋放掉機鎖，其他執行緒可以訪問該物件。

Yield()方法是停止當前執行緒，讓同等優先權的執行緒執行。如果沒有同等優先權的執行緒，那麼Yield()方法將不會起作用。

一個執行緒結束的標誌是：run()方法結束。

一個機鎖被釋放的標誌是：synchronized塊或方法結束。

Wait()方法和notify()方法：當一個執行緒執行到wait()方法時(執行緒休眠且釋放機鎖)，它就進入到一個和該物件相關的等待池中，同時失去了物件的機鎖。當它被一個notify()方法喚醒時，等待池中的執行緒就被放到了鎖池中。該執行緒從鎖池中獲得機鎖，然後回到wait()前的中斷現場。

join()方法使當前執行緒停下來等待，直至另一個呼叫join方法的執行緒終止。

值得注意的是：執行緒的在被啟用後不一定馬上就執行，而是進入到可執行執行緒的佇列中。

共同點： 他們都是在多執行緒的環境下，都可以在程式的呼叫處阻塞指定的毫秒數，並返回。

不同點： Thread.sleep(long)可以不在synchronized的塊下呼叫，而且使用Thread.sleep()不會丟失當前執行緒對任何物件的同步鎖(monitor);

object.wait(long)必須在synchronized的塊下來使用，呼叫了之後失去對object的monitor, 這樣做的好處是它不影響其它的執行緒對object進行操作。

舉個java.util.Timer的例子來說明。

private void mainLoop() {

while (true) {

....

synchronized(queue) {

.....

if (!taskFired) // Task hasn"t yet fired; wait

queue.wait(executionTime - currentTime);

}

}

在這裡為什麼要使用queue.wait()，而不是Thread.sleep(), 是因為暫時放棄queue的物件鎖，可以讓允許其它的執行緒執行一些同步操作。如：

private void sched(TimerTask task, long time, long period) {

synchronized(queue) {

...

queue.add(task);

}

}

但是正如上篇文章講到的，使用queue.wait(long)的前提條件是sched()動作執行的時間很短，否則如果很長，那麼queue.wait()不能夠按時醒來。

(2)

前面講了wait/notify機制，Thread還有一個sleep()靜態方法，它也能使執行緒暫停一段時間。sleep與wait的不同點是：sleep並不釋放鎖，並且sleep的暫停和wait暫停是不一樣的。obj.wait會使執行緒進入obj物件的等待集合中並等待喚醒。

但是wait()和sleep()都可以通過interrupt()方法打斷執行緒的暫停狀態，從而使執行緒立刻丟擲InterruptedException。

如果執行緒A希望立即結束執行緒B，則可以對執行緒B對應的Thread例項呼叫interrupt方法。如果此刻執行緒B正在wait/sleep/join，則執行緒B會立刻丟擲InterruptedException，在catch() {} 中直接return即可安全地結束執行緒。

需要注意的是，InterruptedException是執行緒自己從內部丟擲的，並不是interrupt()方法丟擲的。對某一執行緒呼叫interrupt()時，如果該執行緒正在執行普通的程式碼，那麼該執行緒根本就不會丟擲InterruptedException。但是，一旦該執行緒進入到wait()/sleep()/join()後，就會立刻丟擲InterruptedException。

　sleep()、suspend()、resume()方法不推薦使用，推薦使用wait()、notify()、notifyAll()。

　　sleep()方法是使執行緒停止一段時間的方法。在sleep 時間間隔期滿後，執行緒不一定立即恢復執行。這是因為在那個時刻，其它執行緒可能正在執行而且沒有被排程為放棄執行，除非

　　(a)“醒來”的執行緒具有更高的優先順序。

　　(b)正在執行的執行緒因為其它原因而阻塞。

　　wait()是執行緒互動時，如果執行緒對一個同步物件x 發出一個wait()呼叫，該執行緒會暫停執行，被調物件進入等待狀態，直到被喚醒或等待時間到。

　　當呼叫wait()後，執行緒會釋放掉它所佔有的“鎖標誌”，從而使執行緒所在物件中的其它synchronized資料可被別的執行緒使用。

　　waite()和notify()因為會對物件的“鎖標誌”進行操作，所以它們必須在synchronized函式或synchronized　block中進行呼叫。如果在non-synchronized函式或non-synchronized　block中進行呼叫，雖然能編譯通過，但在執行時會發生IllegalMonitorStateException的異常。

(3)

下面是我原來在CSDN論壇上看到的一個貼子，涉及到同步,wait(),notify()等概念的理解，我試著根據原來的一些回覆和Think in Java上的相關概念將wait()和notify()這兩個方法剖析了一下，歡迎指教.

問題如下：

class ThreadA

{

public static void main(String[] args)

{

ThreadB b=new ThreadB();

b.start();

System.out.println("b is start....");

synchronized(b)//括號裡的b是什麼意思,起什麼作用?

{

try

{

System.out.println("Waiting for b to complete...");

b.wait();//這一句是什麼意思，究竟讓誰wait?

System.out.println("Completed.Now back to main thread");

}catch (InterruptedException e){}

}

System.out.println("Total is :"+b.total);

}

}

class ThreadB extends Thread

{

int total;

public void run()

{

synchronized(this)

{

System.out.println("ThreadB is running..");

for (int i=0;i<100;i++ )

{

total +=i;

System.out.println("total is "+total);

}

notify();

}

}

}

要分析這個程式,首先要理解notify()和wait(),為什麼在前幾天記錄執行緒的時候沒有紀錄這兩個方法呢,因為這兩個方法本來就不屬於Thread類,而是屬於最底層的object基礎類的,也就是說不光是Thread，每個物件都有notify和wait的功能，為什麼？因為他們是用來操縱鎖的,而每個物件都有鎖,鎖是每個物件的基礎,既然鎖是基礎的,那麼操縱鎖的方法當然也是最基礎了.

再往下看之前呢,首先最好複習一下Think in Java的14.3.1中第3部分內容：等待和通知,也就是wait()和notify了.

按照Think in Java中的解釋:"wait()允許我們將執行緒置入“睡眠”狀態，同時又“積極”地等待條件發生改變.而且只有在一個notify()或notifyAll()發生變化的時候，執行緒才會被喚醒，並檢查條件是否有變."

我們來解釋一下這句話.

"wait()允許我們將執行緒置入“睡眠”狀態",也就是說,wait也是讓當前執行緒阻塞的,這一點和sleep或者suspend是相同的.那和sleep,suspend有什麼區別呢?

區別在於"(wait)同時又“積極”地等待條件發生改變",這一點很關鍵,sleep和suspend無法做到.因為我們有時候需要通過同步（synchronized）的幫助來防止執行緒之間的衝突，而一旦使用同步,就要鎖定物件，也就是獲取物件鎖,其它要使用該物件鎖的執行緒都只能排隊等著,等到同步方法或者同步塊裡的程式全部執行完才有機會.在同步方法和同步塊中,無論sleep()還是suspend()都不可能自己被呼叫的時候解除鎖定,他們都霸佔著正在使用的物件鎖不放.

而wait卻可以,它可以讓同步方法或者同步塊暫時放棄物件鎖,而將它暫時讓給其它需要物件鎖的人(這裡應該是程式塊,或執行緒)用,這意味著可在執行wait()期間呼叫執行緒物件中的其他同步方法!在其它情況下(sleep啊,suspend啊),這是不可能的.

但是注意我前面說的,只是暫時放棄物件鎖,暫時給其它執行緒使用,我wait所在的執行緒還是要把這個物件鎖收回來的呀.wait什麼?就是wait別人用完了還給我啊！

好,那怎麼把物件鎖收回來呢?

第一種方法,限定借出去的時間.在wait()中設定引數,比如wait(1000),以毫秒為單位,就表明我只借出去1秒中,一秒鐘之後,我自動收回.

第二種方法,讓借出去的人通知我,他用完了,要還給我了.這時,我馬上就收回來.哎,假如我設了1小時之後收回,別人只用了半小時就完了,那怎麼辦呢?靠!當然用完了就收回了,還管我設的是多長時間啊.

那麼別人怎麼通知我呢?相信大家都可以想到了,notify(),這就是最後一句話"而且只有在一個notify()或notifyAll()發生變化的時候，執行緒才會被喚醒"的意思了.

因此,我們可將一個wait()和notify()置入任何同步方法或同步塊內部，無論在那個類裡是否準備進行涉及執行緒的處理。而且實際上,我們也只能在同步方法或者同步塊裡面呼叫wait()和notify().

這個時候我們來解釋上面的程式,簡直是易如反掌了.

synchronized(b){...}；的意思是定義一個同步塊,使用b作為資源鎖。b.wait();的意思是臨時釋放鎖，並阻塞當前執行緒,好讓其他使用同一把鎖的執行緒有機會執行,在這裡要用同一把鎖的就是b執行緒本身.這個執行緒在執行到一定地方後用notify()通知wait的執行緒,鎖已經用完,待notify()所在的同步塊執行完之後,wait所在的執行緒就可以繼續執行.

1) sleep()使當前執行緒進入停滯狀態，所以執行sleep()的執行緒在指定的時間內肯定不會執行；yield()只是使當前執行緒重新回到可執行狀態，所以執行yield()的執行緒有可能在進入到可執行狀態後馬上又被執行。

2) sleep()可使優先順序低的執行緒得到執行的機會，當然也可以讓同優先順序和高優先順序的執行緒有執行的機會；yield()只能使同優先順序的執行緒有執行的機會。