【JavaSE专栏84】线程让步，一种线程调度的机制

Designer 小郑

发布于 2023-08-24 12:17:38

24800

代码可运行

文章被收录于专栏：跟着小郑学JAVA跟着小郑学JAVA

运行总次数：0

代码可运行

作者主页：Designer 小郑 作者简介：3年JAVA全栈开发经验，专注JAVA技术、系统定制、远程指导，致力于企业数字化转型，CSDN学院、蓝桥云课认证讲师。 主打方向：Vue、SpringBoot、微信小程序

本文讲解了 Java 中线程让步的语法和应用场景，并给出了样例代码。线程让步是一种线程调度的机制，当线程调用 Thread.yield() 方法时，它就会主动放弃当前的CPU执行时间片，让给其他具有相同优先级的线程执行。

一、什么是线程让步

线程让步是一种线程调度的机制。

当线程调用 Thread.yield() 方法时，它就会主动放弃当前的CPU执行时间片，让给其他具有相同优先级的线程执行。

实际上，线程让步是一种提醒调度器当前线程已经完成了当前阶段的任务，可以进行线程切换，但是不保证一定发生线程切换，调度器可能会忽略这个提醒，继续执行当前线程。

调用 Thread.yield() 的线程会从运行状态转换到就绪状态，与其他就绪状态的线程竞争 CPU 的执行权。

如果没有其他线程处于就绪状态，那么当前线程仍然可以继续执行。

但是，一般情况下，调用 Thread.yield() 会导致当前线程让出 CPU 的使用权，使得其他具有相同优先级的线程有机会获得执行。

线程让步的主要作用是使得多个具有相同优先级的线程能够公平竞争 CPU 的执行时间，避免某个线程长时间霸占 CPU 而导致其他线程无法执行的情况，但线程让步并不保证公平性，具体的执行顺序还是由操作系统的线程调度器决定。

过度使用线程让步可能会导致性能下降，因为频繁地进行线程切换会带来一定的开销，因此开发者应该谨慎使用线程让步，只在必要的时候使用。

二、什么情况下产生线程让步

线程让步是一种线程调度机制，线程可以主动放弃当前的CPU执行时间片，让给其他具有相同优先级的线程执行。

线程让步的情况主要有以下

种，请同学们认真学习。

当前线程执行完了一部分任务，希望让其他线程有机会执行。可以通过调用 Thread 类的 yield() 方法来实现线程让步。调用 yield() 方法会让当前线程从运行状态转换到就绪状态，与其他具有相同优先级的线程竞争 CPU 的执行权。
当前线程遇到一些临时的阻塞条件，希望让其他线程先执行。例如，线程在执行过程中发现某个共享资源不可用，为了避免浪费 CPU 的时间，可以让出执行权，等待资源可用后再继续执行。
当前线程执行的任务比较重，为了避免长时间占用 CPU 而导致其他线程无法执行，可以适当让步，让其他线程有机会执行。

线程让步并不保证一定会发生线程切换，具体是否发生线程切换还是由操作系统的线程调度器决定，另外过度地使用线程让步可能会导致性能下降，因为频繁地进行线程切换会带来一定的开销，所以在使用线程让步时需要谨慎考虑。

三、模拟线程让步

以下是一个使用 Java 模拟线程让步的示例代码，请同学们复制到本地执行。

public class ThreadYieldExample {
    public static void main(String[] args) {
        Runnable myRunnable = new MyRunnable();

        Thread thread1 = new Thread(myRunnable, "Thread 1");
        Thread thread2 = new Thread(myRunnable, "Thread 2");

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

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " is running");

                // 模拟某个条件需要让步，让其他线程先执行
                if (i == 2 && Thread.currentThread().getName().equals("Thread 1")) {
                    System.out.println(Thread.currentThread().getName() + " is yielding");
                    Thread.yield();
                }

                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在这个示例中，我们创建了两个线程 Thread 1 和 Thread 2，它们都执行同一个 MyRunnable 任务。

在 MyRunnable 的 run() 方法中，每个线程会打印自己的名字并休眠

500

毫秒。

当 i 等于

且当前线程的名字是 Thread 1 时，我们通过 Thread.yield() 方法进行线程让步，让给其他线程执行。

运行程序后,可以看到在 Thread 1 执行到一定条件时，它会让步给 Thread 2 执行一段时间，然后继续自己的执行。

这样就模拟了 Java 线程让步的效果。

四、线程让步的应用场景

线程让步是一种线程调度机制，可以让当前线程主动放弃 CPU 执行时间片，让给其他具有相同优先级的线程执行。

线程让步的应用场景主要包括以下

种情况，请同学们认真学习。

公平竞争 CPU 资源：在多线程环境下，希望各个线程能够公平地竞争 CPU 的执行时间，避免某个线程长时间占用 CPU 而导致其他线程无法执行。通过在适当的时候调用 Thread.yield() 方法，可以让当前线程让出 CPU 执行权，给其他线程执行的机会。
协同处理任务：在某些任务中，不同线程的处理速度可能不一致，为了提高整体的处理效率，可以让处理速度较快的线程让步，让处理速度较慢的线程有机会追赶上来。这样可以确保各个线程以合理的速度协同工作。
避免线程饥饿：线程饥饿是指某个线程由于优先级较低或其他原因，一直无法获取到 CPU 的执行时间片，导致无法执行任务。通过适当使用线程让步，可以让优先级较低的线程有机会执行，避免线程饥饿的问题。
提高响应性：在某些场景下，需要实现较为及时的响应，例如处理用户请求、消息处理等，通过在关键代码片段中适当调用 Thread.yield() 方法，可以让其他线程有机会及时执行，提高整体的响应性能。

在使用线程让步时需要谨慎，过度使用可能会导致性能下降，合理地使用线程让步可以提升多线程程序的效率和响应性。

五、线程让步面试题

问题：什么是线程让步？如何在Java中实现线程让步？

线程让步是一种线程调度机制，它允许一个线程主动放弃 CPU 执行时间片，让给其他具有相同优先级的线程执行。

在 Java 中，可以通过 Thread 类的 yield() 方法来实现线程让步。

调用 yield() 方法会使当前线程从运行状态转换到就绪状态，然后与其他具有相同优先级的线程竞争 CPU 的执行权。

调用 yield() 方法的线程并不能保证一定会切换到其他线程，具体是否发生线程切换还是由操作系统的线程调度器决定。

示例代码如下。

public class ThreadYieldExample {
    public static void main(String[] args) {
        Runnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable, "Thread1");
        Thread thread2 = new Thread(myRunnable, "Thread2");
        thread1.start();
        thread2.start();
    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " is running");
                // 模拟某个条件需要让步，让其他线程先执行
                if (i == 2 && Thread.currentThread().getName().equals("Thread1")) {
                    System.out.println(Thread.currentThread().getName() + " is yielding");
                    Thread.yield();
                }
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}