Thread.yield()用法及解释

我们知道在jvm中的并发并非真正的并发，而是cpu将执行过程划分为了时间片，在程序执行过程中，cpu会根据自身的规则分别去调度各个线程。只是这个时间片很短所以给我们的感觉像是并发。某一个线程得到执行也就是这个线程获取到了cpu的执行权。

这里再补充一个刚想到的知识点，与yield无关：每个线程内部都有一个程序计数器大体的作用是用于标记当前执行到的代码行数等信息，当某个线程执行过程中cpu执行权被释放的时候，该线程当前执行的相关数据会被存在程序计数器中，等下次该线程重新获得cpu执行权的时候，jvm会从该线程的程序计数器中恢复该线程之前的执行状态

我们来看一下yield的方法定义：

public static native void yield();

这是个静态native方法，意思是让出当前正在执行的线程的cpu执行权并让其进入可运行状态以允许具有相同优先级的其他线程获得运行的机会，仅仅只有这个作用。但是该方法并不能保证cpu的执行权一定被让出了，正如上面说的，cpu调度哪个线程来执行并不是确定的，所以也有可能当前线程刚刚把执行权让出来马上cpu又将执行权分配给它。该方法在实际应用中其实很少，反正我是没用过。可能的应用场景我觉得应该是某个线程业务中并不是那么重要，所以在某个适当的时机把它让出去让其他的线程先走，例如我觉得像一些应用启动时的日志上报等操作，为了避免它占用过多的cpu资源，先把该线程yield一下。

我们来看个yield的简单使用代码：

public void main() {
    Thread thread1 = new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(300L);
                if (i == 10) {
                    //执行到第20的时候，让出cpu执行权，让cpu重新分配，有可能cpu还是会把执行权分配给本线程
                    Thread.yield();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在执行：" + i);
        }
    }, "thread1");
    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(300L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在执行：" + i);
        }
    }, "thread2");

    thread1.start();
    thread2.start();
}

这个例子中其实程序的每次输出都是不一样的，所以真正的意义不大。

但是因为有这么个方法，为了大家使用的时候能真正了解它的影响，我们还是得进行更深一步的思考，就是yield之后，cpu资源被释放了那如果该线程中持有了某个锁，这个锁会被释放吗？接下来我们来试验一下

Thread.yield()是否会释放锁

我们将上面的例子进行改造：

Object lock = new Object();

    public void main() {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(300L);
                        if (i == 5) {
                            //执行到第20的时候，让出cpu执行权，让cpu重新分配，有可能cpu还是会把执行权分配给本线程
                            Thread.yield();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在执行：" + i);
                }
            }
        }, "thread1");
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(300L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在执行：" + i);
                }
            }
        }, "thread2");

        thread1.start();
        try {
            //这个sleep我们是为了尽可能保证thread2会比thread1更晚执行
            Thread.sleep(100L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();

    }

上面例子的输出结果：

thread1正在执行：0
thread1正在执行：1
thread1正在执行：2
thread1正在执行：3
thread1正在执行：4
thread1正在执行：5
thread1正在执行：6
thread1正在执行：7
thread1正在执行：8
thread1正在执行：9
thread2正在执行：0
thread2正在执行：1
thread2正在执行：2
thread2正在执行：3
thread2正在执行：4

并且每次执行的结果都是一样的，我们可以看出，thread1被释放执行权的时候，因为锁并没有被释放，所以当cpu把执行权分配给thread2的时候，由于thread2没有获得lock锁所以被阻塞，内部的打印永远都打印不出来除非等到thread1执行完。

总结：

1.Thread.yield()会让出当前正在执行的线程的cpu执行权并让其进入可运行状态以允许具有相同优先级的其他线程获得运行的机会。

2.Thread.yield()只会释放当前cpu资源，如果该线程中持有锁的话，不会释放该持有的锁资源

希望本文章能对ThreadThread.yield()还不熟悉的朋友有点参考意义