JAVAsleep與wait區別

⑴ java中的sleep和wait的區別

java中的sleep和wait的區別如下：
1、所屬的超類不同：sleep屬於線程Thread類的方法，而wait屬於Object方法
2、用法不同：
①sleep()方法導致了程序暫停執行指定的時間，讓出cpu該其他線程，但是他的監控狀態依然保持者，當指定的時間到了又會自動恢復運行狀態。
②調用wait()方法的時候，線程會放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象調用notify()方法後本線程才進入對象鎖定池准備
3、舉例說明：
wait方法：
private static class Thread1 implements Runnable{
@Override
public void run(){
synchronized (TestD.class) {
System.out.println("enter thread1...");
System.out.println("thread1 is waiting...");
try {
//調用wait()方法，線程會放棄對象鎖，進入等待此對象的等待鎖定池
TestD.class.wait();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("thread1 is going on ....");
System.out.println("thread1 is over!!!");
}
}
}
sleep方法用法：
private static class Thread2 implements Runnable{
@Override
public void run(){
synchronized (TestD.class) {
System.out.println("enter thread2....");
System.out.println("thread2 is sleep....");
//只有針對此對象調用notify()方法後本線程才進入對象鎖定池准備獲取對象鎖進入運行狀態。
TestD.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!!!");
}
}
}
運行結果：
enter thread1...
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over
thread1 is going on ....
thread1 is over

⑵ java中wait和sleep的區別

1.對於sleep()方法，是屬於Thread類中的。而wait()方法，則是屬於Object類中的。
2.最主要是sleep方法沒有釋放鎖，而 wait 方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。
3.wait，notify和notifyAll只能在同步控制方法或者同步控制塊裡面使用，而sleep可以在任何地方使用

4.sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常
5、sleep()是讓某個線程暫停運行一段時間,其控制范圍是由當前線程決定,也就是說,在線程裡面決定；wait(),首先,這是由某個確定的對象來調用的,將這個對象理解成一個傳話的人,當這個人在某個線程裡面說"暫停!",

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

1、同步鎖的對待不同：

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

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

2、用法的不同：

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

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

3、屬於不同的類：

sleep（）的類是Thread。

wait（）的類是Object。

⑷ sleep和wait的區別

sleep和wait的區別：

1、sleep是Thread的靜態方法，wait是Object的方法，任何對象實例都能調用。

2、sleep不會釋放鎖，它也不需要佔用鎖。wait會釋放鎖，但調用它的前提是當前線程佔有鎖（即代碼要在synchronized中）。

3、它們都可以被interrupted方法中斷。

具體來說：

Thread.Sleep(1000)意思是在未來的1000毫秒內本線程不參與CPU競爭，1000毫秒過去之後，這時候也許另外一個線程正在使用CPU，那麼這時候操作系統是不會重新分配CPU的，直到那個線程掛起或結束。

即使這個時候恰巧輪到操作系統進行CPU分配，那麼當前線程也不一定就是總優先順序最高的那個，CPU還是可能被其他線程搶佔去。另外值得一提的是Thread.Sleep(0)的作用，就是觸發操作系統立刻重新進行一次CPU競爭，競爭的結果也許是當前線程仍然獲得CPU控制權，也許會換成別的線程獲得CPU控制權。

wait(1000)表示將鎖釋放1000毫秒，到時間後如果鎖沒有被其他線程佔用，則再次得到鎖，然後wait方法結束，執行後面的代碼，如果鎖被其他線程佔用，則等待其他線程釋放鎖。

注意，設置了超時時間的wait方法一旦過了超時時間，並不需要其他線程執行notify也能自動解除阻塞，但是如果沒設置超時時間的wait方法必須等待其他線程執行notify。

⑸ java sleep 和wait的區別

java中sleep和wait的區別主要有兩點，第一sleep必須指定時間，而wait可以指定也可以不指定；第二在同步中，sleep釋放cpu執行權，但是不釋放鎖，而wait釋放cpu執行權和鎖。
java中sleep和wait都是讓線程休眠的方法，它們都是阻塞方法。在同步中，需要注意根據具體的需求來選擇使用sleep和wait。

⑹ 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()的時候,那麼我就可以煮飯了,這個被暫停的線程就會從暫停處

⑺ wait方法和sleep方法的區別

1. Java中sleep和wait的區別

① 這兩個方法來自不同的類分別是，sleep來自Thread類，和wait來自Object類。

sleep是Thread的靜態類方法，誰調用的誰去睡覺，即使在a線程里調用b的sleep方法，實際上還是a去睡覺，要讓b線程睡覺要在b的代碼中調用sleep。

② 鎖: 最主要是sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。

sleep不出讓系統資源；wait是進入線程等待池等待，出讓系統資源，其他線程可以佔用CPU。一般wait不會加時間限制，因為如果wait線程的運行資源不夠，再出來也沒用，要等待其他線程調用notify/notifyAll喚醒等待池中的所有線程，才會進入就緒隊列等待OS分配系統資源。sleep(milliseconds)可以用時間指定使它自動喚醒過來，如果時間不到只能調用interrupt()強行打斷。

Thread.sleep(0)的作用是「觸發操作系統立刻重新進行一次CPU競爭」。

③ 使用范圍：wait，notify和notifyAll只能在同步控制方法或者同步控制塊裡面使用，而sleep可以在任何地方使用。

synchronized(x){
x.notify()
//或者wait()
}

2. Java中HashMap和HashTable的區別

① 歷史原因: Hashtable是給予陳舊的Dictonary類的, HashMap是Java1.2引進的Map介面的一個實現

② HashMap允許空的鍵值對, 而HashTable不允許

③ HashTable同步，而HashMap非同步，效率上比HashTable要高

3. 請簡述在異常當中，throw和throws有什麼區別

① throw代表動作，表示拋出一個異常的動作；throws代表一種狀態，代表方法可能有異常拋出
② throw用在方法實現中，而throws用在方法聲明中
③ throw只能用於拋出一種異常，而throws可以拋出多個異常

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

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

⑼ 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 中 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
講了挺多。我也覺得啰嗦。但是應該通俗易懂吧。