javawaitsleep

① java裡面的wait方法（object類中的）和sleep（）方法有什麼本質上的區別，詳解1··

首先，sleep()是Thread類中的方法，而wait()則是Object類中的方法。

sleep()方法導致了程序暫停，但是他的監控狀態依然保持著，當指定的時間到了又會自動恢復運行狀態。在調用sleep()方法的過程中，線程不會釋放對象鎖。
wait()方法會導致線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象調用notify()方法後本線程才進入對象鎖定池准備獲取對象鎖進入運行狀態。

以下以代碼為例講解：
package test;
public class WaitAndSleep {

public static void main(String[] args) {
new Thread(new Thread1()).start();
try {
Thread.sleep(5000);
} catch (Exception e) {
e.printStackTrace();
}
new Thread(new Thread2()).start();
}

private static class Thread1 implements Runnable {
@Override
public void run() {
synchronized (WaitAndSleep.class) {

System.out.println("thread1 is waiting...");
try {
// 調用wait()方法，線程會放棄對象鎖，進入等待此對象的等待鎖定池
WaitAndSleep.class.wait();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("thread1 is going on ....");
System.out.println("thread1 is over!!!");
}
}
}

private static class Thread2 implements Runnable {
@Override
public void run() {
synchronized (WaitAndSleep.class) {
System.out.println("enter thread2....");
System.out.println("thread2 is sleep....");
// 只有針對此對象調用notify()方法後本線程才進入對象鎖定池准備獲取對象鎖進入運行狀態。
WaitAndSleep.class.notify();
// ==================
// 區別
// 如果我們把代碼：TestD.class.notify();給注釋掉，即TestD.class調用了wait()方法，但是沒有調用notify()
// 方法，則線程永遠處於掛起狀態。
try {
// sleep()方法導致了程序暫停執行指定的時間，讓出cpu該其他線程，
// 但是他的監控狀態依然保持者，當指定的時間到了又會自動恢復運行狀態。
// 在調用sleep()方法的過程中，線程不會釋放對象鎖。
Thread.sleep(5000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("thread2 is going on....");
System.out.println("thread2 is over!!!");
}
}
}
}

運行結果：
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over!!!
thread1 is going on ....
thread1 is over!!!

如果我們把代碼：WaitAndSleep.class.notify();給注釋掉
運行結果：
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over!!!
程序一直處於掛起狀態，無法結束

② 2020-09-15：java里的wait()和sleep()的區別有哪些

1: 方法所在類不同 wait是object類中的方法 sleep是Thread類中的方法
2: wait方法釋放鎖 sleep不釋放鎖
3: wait方法會使得線程進入線程等待池中 需要使用notify方法喚醒,sleep方法在指定的時間過後則自動蘇醒

③ java wait和sleep的區別

第一種解釋：

功能差不多,都用來進行線程式控制制,他們最大本質的區別是:sleep()不釋放同步鎖,wait()釋放同步縮.

還有用法的上的不同是:sleep(milliseconds)可以用時間指定來使他自動醒過來,如果時間不到你只能調用interreput()來強行打斷;wait()可以用notify()直接喚起.

第二種解釋：

sleep是Thread類的靜態方法。sleep的作用是讓線程休眠制定的時間，在時間到達時恢復，也就是說sleep將在接到時間到達事件事恢復線程執行，例如：

try{
System.out.println("I'm going to bed");
Thread.sleep(1000);
System.out.println("I wake up");
}
catch(IntrruptedException e) {
}

wait是Object的方法，也就是說可以對任意一個對象調用wait方法，調用wait方法將會將調用者的線程掛起，直到其他線程調用同一個對象的notify方法才會重新激活調用者，例如：

//Thread 1

try{
obj.wait();//suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}

第三種解釋：

這兩者的施加者是有本質區別的.
sleep()是讓某個線程暫停運行一段時間,其控制范圍是由當前線程決定,也就是說,在線程裡面決定.好比如說,我要做的事情是 "點火->燒水->煮麵",而當我點完火之後我不立即燒水,我要休息一段時間再燒.對於運行的主動權是由我的流程來控制.

而wait(),首先,這是由某個確定的對象來調用的,將這個對象理解成一個傳話的人,當這個人在某個線程裡面說"暫停!",也是
thisOBJ.wait(),這里的暫停是阻塞,還是"點火->燒水->煮飯",thisOBJ就好比一個監督我的人站在我旁邊,本來該線
程應該執行1後執行2,再執行3,而在2處被那個對象喊暫停,那麼我就會一直等在這里而不執行3,但這個流程並沒有結束,我一直想去煮飯,但還沒被允許,

直到那個對象在某個地方說"通知暫停的線程啟動!",也就是thisOBJ.notify()的時候,那麼我就可以煮飯了,這個被暫停的線程就會從暫停處

④ java 中 sleep 和 wait 的區別

首先：sleep是通過線程來調用的。它是Thread身上的方法。而wait是Object身上的方法。
所以調用的時候需要用object來調用。
其次：原理不同。當前線程在同步代碼塊中，調用sleep之後，當前線程並沒有釋放鎖。意味著
其他線程如果競爭這個鎖。就要等待。
而當前線程在同步代碼塊中調用obj.wait之後。當前線程已經釋放鎖了。意味著其他對象，如果競爭
這個鎖。不需要等待。
說這么多，不如上代碼。場景：兩個線程同時競爭一個資源。使用同步代碼塊。
①競爭同一個obj對象，使用sleep。
publicclassTestSleep{
publicstaticvoidmain(String[]args)throwsException{
		finalObjectobj=newObject();
		finalThreadt1=newThread(){
			@Override
			publicvoidrun(){
				synchronized(obj){
					try{
						Thread.sleep(1000);
					}catch(InterruptedExceptione){
						e.printStackTrace();
					}
					System.out.println("1");
				}
			}
		};
		finalThreadt2=newThread(){
			@Override
			publicvoidrun(){
				synchronized(obj){
					System.out.println("2");
				}
			}
		};
		t1.start();
		Thread.sleep(100);//確保t1先執行。先搶到obj的控制權。
		t2.start();
	}
}
分析：創建一個obj。兩條線程。Thread.sleep(100);確保讓t1先執行到run方法。所以t1會
先搶到obj的資源，給它上鎖。需要睡000ms，並不釋放obj鎖。此時t2已經跑起來，走到run方法同步代碼塊。
發現obj已經被t1搶到了。所以t2隻能等t1釋放obj鎖。而t1什麼時候釋放obj鎖？t1的同步代碼
塊執行完釋放。什麼時候執行完？列印1的時候執行完。t1釋放鎖之後。t2得到鎖。因為這里只有兩條
線程競爭obj鎖。所以接下來就列印2。
最終結果是先列印1再列印2。

再看另個一例子：
②競爭同一個obj對象，使用wait。
publicclassTestWaint{
publicstaticvoidmain(String[]args)throwsException{
		finalObjectobj=newObject();
		finalThreadt1=newThread(){
			@Override
			publicvoidrun(){
				synchronized(obj){
					try{
						obj.wait();
					}catch(InterruptedExceptione){
						e.printStackTrace();
					}
					System.out.println("1");
				}
			}
		};
		finalThreadt2=newThread(){
			@Override
			publicvoidrun(){
				synchronized(obj){
					System.out.println("2");
					obj.notify();
				}
			}
		};
		t1.start();
		Thread.sleep(100);//確保t1先執行。
		t2.start();
	}
}

分析：創建一個obj。兩條線程。Thread.sleep(100);確保讓t1先執行到run方法。所以t1會
先搶到obj的資源，給它上鎖。然而接下來t1中調用了obj.wait();這個代碼，表示t1放棄對obj
的擁有權。也就是釋放鎖。（釋放了之後它需要等待。而不是往下執行，等待什麼？等待別人喚醒。
因為wait和notify方法相對。必須要有一個線程調用obj.nofity();時，t1才有可能再次蘇醒。否則永遠等待。）
t1釋放鎖，進入等待。意味著t2不用等到t1的同步代碼塊結束，就可以獲取到obj的控制權。
所以t2就給obj上鎖了。所以t2先列印2。然後調用了obj.nofity();此時t2已經結束。
由於沒有其他線程和t1競爭。此時t1蘇醒，再次獲獲得obj的控制權。往下走，t1線程結束。
所以：先列印2再列印1
講了挺多。我也覺得啰嗦。但是應該通俗易懂吧。

⑤ java中sleep和wait的區別

它們最大本質的區別是:sleep()不釋放同步鎖,wait()釋放同步鎖.
還有用法的上的不同是:sleep(milliseconds)可以用時間指定來使他自動醒過來,如果時間不到你只能調用interreput()來強行打斷;wait()可以用notify()直接喚起.

sleep和wait的區別還有：
1。這兩個方法來自不同的類分別是Thread和Object
2。最主要是sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。
3。wait，notify和notifyAll只能在同步控制方法或者同步控制塊裡面使用，而sleep可以在
任何地方使用
synchronized(x){
x.notify()
//或者wait()
}
4。sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常

⑥ Java中Wait，Sleep和Yield方法的區別

共同點：
1. 他們都是在多線程的環境下，都可以在程序的調用處阻塞指定的毫秒數，並返回。
2. 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 。
不同點：
1. Thread類的方法：sleep(),yield()等
Object的方法：wait()和notify()等
2. 每個對象都有一個鎖來控制同步訪問。Synchronized關鍵字可以和對象的鎖交互，來實現線程的同步。
sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。
3. wait，notify和notifyAll只能在同步控制方法或者同步控制塊裡面使用，而sleep可以在任何地方使用
4. sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常

⑦ java sleep（） 和 wait（） 有什麼區別

1、同步鎖的對待不同：

sleep（）後，程序並不會不釋放同步鎖。

wait（）後，程序會釋放同步鎖。

2、用法的不同：

sleep（）可以用時間指定來使他自動醒過來。如果時間不到你只能調用interreput()來強行打斷。

wait（）可以用notify()直接喚起。

3、屬於不同的類：

sleep（）的類是Thread。

wait（）的類是Object。

⑧ java中的sleep和wait的區別

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函數或synchronizedblock中進行調用。如果在non-synchronized函數或non-synchronizedblock中進行調用，雖然能編譯通過，但在運行時會發生IllegalMonitorStateException的異常。

⑨ java的sleep()和wait()

wait()、notify()、notifyAll()這三個方法是Object中的方法，跟鎖類似。
當t1沒有獲取這個object時wait，其他線程釋放object後叫notify，然後t1立即繼續執行。

sleep()跟上面這三個不一樣，是Thread中的方法，不需要等待資源被釋放，sleep有一個時間傳參，想讓線程等待多會兒就等待多會兒，不需要其他線程喚醒。例如：
try{
t1.sleep(1000); //t1等待1秒後繼續執行下面的內容
}catch(Exception e){}