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();
        }
    }
}

执行结果：不管如何重复执行，一个线程只能等另外一个线程执行完后才能执行。