yieldJava

㈠ java線程的sleep和yield的區別

1、sleep()
使當前線程（即調用該方法的線程）暫停執行一段時間，讓其他線程有機會繼續執行，但它並不釋放對象鎖。也就是說如果有synchronized同步快，其他線程仍然不能訪問共享數據。注意該方法要捕捉異常。
例如有兩個線程同時執行(沒有synchronized)一個線程優先順序為MAX_PRIORITY，另一個為MIN_PRIORITY，如果沒有Sleep()方法，只有高優先順序的線程執行完畢後，低優先順序的線程才能夠執行；但是高優先順序的線程sleep(500)後，低優先順序就有機會執行了。
總之，sleep()可以使低優先順序的線程得到執行的機會，當然也可以讓同優先順序、高優先順序的線程有執行的機會。

2、join()
join()方法使調用該方法的線程在此之前執行完畢，也就是等待該方法的線程執行完畢後再往下繼續執行。注意該方法也需要捕捉異常。

3、yield()
該方法與sleep()類似，只是不能由用戶指定暫停多長時間，並且yield（）方法只能讓同優先順序的線程有執行的機會。

4、wait()和notify()、notifyAll()

這三個方法用於協調多個線程對共享數據的存取，所以必須在synchronized語句塊內使用。synchronized關鍵字用於保護共享數據，阻止其他線程對共享數據的存取，但是這樣程序的流程就很不靈活了，如何才能在當前線程還沒退出synchronized數據塊時讓其他線程也有機會訪問共享數據呢？此時就用這三個方法來靈活控制。
wait()方法使當前線程暫停執行並釋放對象鎖標示，讓其他線程可以進入synchronized數據塊，當前線程被放入對象等待池中。當調用notify()方法後，將從對象的等待池中移走一個任意的線程並放到鎖標志等待池中，只有鎖標志等待池中線程能夠獲取鎖標志；如果鎖標志等待池中沒有線程，則notify()不起作用。
notifyAll()則從對象等待池中移走所有等待那個對象的線程並放到鎖標志等待池中

㈡ java中Thread中yield()這個方法

樓主你錯誤的理解了yiedld這個方法。
yiedld這個方法是讓當前線程回到可執行狀態，以便讓具有相同優先順序的線程進入執行狀態，但不是絕對的。因為虛擬機可能會讓該線程重新進入執行狀態。
讓線程暫時停止可以選擇sleep方法。比如thread.sleep(1000),當前線程睡眠1秒。需要知道的是，1秒後，線程是回到可執行狀態，並不是執行狀態，什麼時候執行那是由虛擬機來決定的。所以sleep(1000)並不是在睡眠1秒後立即執行。

㈢ Java中yield()方法怎麼使用

Thread.yield( )方法：

使當前線程從執行狀態（運行狀態）變為可執行態（就緒狀態）。cpu會從眾多的可執行態里選擇，也就是說，剛剛的那個線程還是有可能會被再次執行到的，並不是說一定會執行其他線程了。

㈣ java中yield()方法如何使用

Thread.yield()方法作用是：暫停當前正在執行的線程對象，並執行其他線程。

yield()應該做的是讓當前運行線程回到可運行狀態，以允許具有相同優先順序的其他線程獲得運行機會。因此，使用yield()的目的是讓相同優先順序的線程之間能適當的輪轉執行。但是，實際中無法保證yield()達到讓步目的，因為讓步的線程還有可能被線程調度程序再次選中。

結論：yield()從未導致線程轉到等待/睡眠/阻塞狀態。在大多數情況下，yield()將導致線程從運行狀態轉到可運行狀態，但有可能沒有效果。
public class TestYield {

public static void main(String[] args) {

MyThread3 t1 = new MyThread3("t1");
MyThread3 t2 = new MyThread3("t2");
t1.start();
t2.start();
}
}

class MyThread3 extends Thread {

MyThread3(String s) {
super(s);
}

public void run() {
for(int i = 1;i <=100; i++) {
System.out.println(getName() + ":"+i);
if(i == 0)
yield();
}
}
}

㈤ java yield的用法

Tread.yield();到這一步就是讓步 讓別的線程執行 別的線程也執行這句話 然後再讓步 另一個線程執行 所以下面這句話 執行不到 是不是這樣？

㈥ java中的yield中文應該翻譯成什麼意思

這個方法是線程方法，當一個線程搶到執行權後，執行到yield（）方法後，就會放棄執行權，其他線程就可以拿到執行權 了。

java實現的一個stack類，其中的Thread.yield()語句沒看太明白。
1) pop()中，為什麼要yield()之後再執行point--?
2) push()中，為什麼要在yield()之後再執行buffer[point]的賦值？
源代碼如下：
class Stack {
private String name;
private String[] buffer=new String[100];
int point=-1;

public Stack(String name){this.name=name;}
public String getName(){return name;}

public synchronized int getPoint(){return point;}

public synchronized String pop() {
this.notifyAll();

while(point==-1){
System.out.println(Thread.currentThread().getName()+": wait");
try{
this.wait();
}catch(InterruptedException e){throw new RuntimeException(e);}
}

String goods = buffer[point];
buffer[point]=null;
Thread.yield();
point--;
return goods;
}
public synchronized void push(String goods) {
this.notifyAll();

while(point==buffer.length-1){
System.out.println(Thread.currentThread().getName()+": wait");
try{
this.wait();
}catch(InterruptedException e){throw new RuntimeException(e);}
}
point++;
Thread.yield();
buffer[point]=goods;
}
}問題補充：

我明白Thread.yield()是為了同步，我的問題是yield()在這里為什麼能保證同步？

或者說，不使用yield()會出現哪些不同步的問題呢？

幫我分析一下，比如說說，沒有yield（）的情況下，一個線程在pop，有可能另外一個線程對它造成什麼樣的不同步？

程序太長，放不下，我放到HI上了，地址如下，多謝各位DX了。。。。

㈦ java中join( )和yield方法有什麼區別和聯系

yield：理論上，yield意味著放手，放棄，投降。一個調用yield()方法的線程告訴虛擬機它樂意讓其他線程佔用自己的位置。這表明該線程沒有在做一些緊急的事情。注意，這僅是一個暗示，並不能保證不會產生任何影響。注意：它是一個靜態的原生(native)方法；它告訴當前正在執行的線程把運行機會交給線程池中擁有相同優先順序的線程；

它不能保證使得當前正在運行的線程迅速轉換到可運行的狀態；它僅能使一個線程從運行狀態轉到可運行狀態，而不是等待或阻塞狀態。

join：線程實例的方法join()方法可以使得一個線程在另一個線程結束後再執行。如果join()方法在一個線程實例上調用，當前運行著的線程將阻塞直到這個線程實例完成了執行。

packagetest;
publicclassYieldExample{
publicstaticvoidmain(String[]args){
Threadprocer=newProcer();
Threadconsumer=newConsumer();
procer.setPriority(Thread.MIN_PRIORITY);
consumer.setPriority(Thread.MAX_PRIORITY);
procer.start();
consumer.start();
}
}
classProcerextendsThread{
publicvoidrun(){
for(inti=0;i<5;i++){
System.out.println("IamProcer:ProcedItem"+i);
Thread.yield();
}
}
}
classConsumerextendsThread{
publicvoidrun(){
for(inti=0;i<5;i++){
System.out.println("IamConsumer:ConsumedItem"+i);
Thread.yield();
}
}
}

packagetest;
publicclassJoinExample{
publicstaticvoidmain(String[]args)throwsInterruptedException{
Threadt=newThread(newRunnable(){
publicvoidrun(){
System.out.println("Firsttaskstarted");
System.out.println("Sleepingfor2seconds");
try
{
Thread.sleep(2000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println("Firsttaskcompleted");
}
});
Threadt1=newThread(newRunnable(){
publicvoidrun(){
System.out.println("Secondtaskcompleted");
}
});
t.start();
t.join();
t1.start();
}
}

㈧ java線程中的yield()

Thread.yield();
Sun
api
明確指出
「暫停當前正在執行的線程對象，並執行其他線程。
」
所以yield()是讓當前線程暫停(由於沒有說明執行其他線程的時間，很有可能，執行了其他同優先順序的線程後馬上又回到該線程了。)，以便讓具有相同優先順序的線程進入執行狀態，但不是絕對的。因為虛擬機可能會讓該線程重新進入執行狀態。
「比如說說，沒有yield()的情況下，一個線程在pop，有可能另外一個線程對它造成什麼樣的不同步?」
那要看你另一個線程的代碼了，如果另一個線程和pop是同步的，那麼用了yield另一個線程執行完後才執行point--;return
goods;不用如果另一個線程用到了point，他的值可能已經是自減也可能是沒自減的。。。

㈨ 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中Wait，Sleep和Yield方法的區別

sleep是線程類（Thread）的方法，導致此線程暫停執行指定時間，給執行機會給其他線程，但是監控狀態依然保持，到時後會自動恢復。調用 sleep不會釋放對象鎖。
wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發出notify方法（或notifyAll）後本線程才進入對象鎖定池准備獲得對象鎖進入運行狀態
yield( )方法使當前線程從執行狀態（運行狀態）變為可執行態（就緒狀態）。cpu會從眾多的可執行態里選擇，也就是說，當前也就是剛剛的那個線程還是有可能會被再次執行到的，並不是說一定會執行其他線程而該線程在下一次中不會執行到了。