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

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