java 線程協做 yield()

 

yield():方法的定義

調用yield方法會讓當前線程交出CPU權限，讓CPU去執行其餘的線程。 可是yield不能控制具體的交出CPU的時間，另外，yield方法只能讓擁有相同優先級的線程有獲取CPU執行時間的機會 (Yield告訴當前正在執行的線程把運行機會交給線程池中擁有相同優先級的線程, cpu會從衆多的可執行態裏選擇.)，優先級高的線程業不必定會得到執行權，他們只是機率上大些。該方法不會釋放鎖。
注意:調用yield方法並不會讓線程進入阻塞狀態，而是讓線程重回就緒狀態，它只須要等待從新獲取CPU執行時間(也就是說，當前也就是剛剛的那個線程仍是有可能會被再次執行到的，
並非說必定會執行其餘線程而該線程在下一次中不會執行到了)。

示例：交出當前cpu的執行權，與其餘線程一塊兒從新獲取cpu的調度

public class ThreadYieldTest {
    static Object object=new Object();
    public static void main(String[] args) {
        Thread thread_a=new Thread(new Thread_a());
        Thread thread_b=new Thread(new Thread_b());
        thread_a.setPriority(Thread.MIN_PRIORITY); //Min Priority
        thread_b.setPriority(Thread.MAX_PRIORITY); //Max Priority
        thread_a.start();
        thread_b.start();
    }
}
class Thread_a implements Runnable{
    @Override
    public void run() {
        try {   
                for(int i=0;i<5;i++){
                    //當i爲3時，該線程就會把CPU時間讓掉，讓其餘或者本身的線程執行（也就是誰先搶到誰執行）  
                    if(i==3){
                        Thread.yield();
                    }
                    System.out.println(Thread.currentThread().getName()+"執行==》"+i);
                }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Thread_b implements Runnable{
    @Override
    public void run() {
        try { 
                for(int i=0;i<5;i++){
                    if(i==3){
                        Thread.yield();
                    }
                    System.out.println(Thread.currentThread().getName()+"執行==》"+i);
                }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 

運行結果：

 第一種狀況：Thread-0 當執行到3時會CPU時間讓掉，這時Thread-1搶到CPU時間並執行。

 第二種狀況：Thread-0 當執行到3時會CPU時間讓掉，這時Thread-0搶到CPU時間並執行。

示例：它跟sleep方法相似，一樣不會釋放鎖。

public class ThreadYieldTest {
    static Object object=new Object();
    public static void main(String[] args) {
        Thread thread_a=new Thread(new Thread_a());
        Thread thread_b=new Thread(new Thread_b());
        thread_a.setPriority(Thread.MIN_PRIORITY); //Min Priority
        thread_b.setPriority(Thread.MAX_PRIORITY); //Max Priority
        thread_a.start();
        thread_b.start();
    }
}
class Thread_a implements Runnable{
    @Override
    public void run() {
        try {   
            synchronized (ThreadYieldTest.object) {
                System.out.println("進入線程"+Thread.currentThread().getName());
                for(int i=0;i<5;i++){
                    //當i爲3時，該線程就會把CPU時間讓掉，讓其餘或者本身的線程執行（也就是誰先搶到誰執行）  
                    if(i==3){
                        Thread.yield();
                    }
                    System.out.println(Thread.currentThread().getName()+"執行==》"+i);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Thread_b implements Runnable{
    @Override
    public void run() {
        try {  
            synchronized (ThreadYieldTest.object) {
                System.out.println("進入線程"+Thread.currentThread().getName());
                for(int i=0;i<5;i++){
                    if(i==3){
                        Thread.yield();
                    }
                    System.out.println(Thread.currentThread().getName()+"執行==》"+i);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

執行結果：不管如何重複執行，一個線程只能等另外一個線程執行完後才能執行。