一切福田，不離方寸，從心而覓，感無不通。

Java 中的 `yield` 关键字：深入解析与应用

在 Java 中，yield 关键字在不同版本有着不同的用途和含义。在 Java 13 及以后的版本中，yield 主要用于 switch 表达式，用于返回一个值；而在多线程编程中，Thread.yield() 方法可以让当前线程让出 CPU 时间片，给其他线程执行的机会。本文将详细介绍 yield 关键字的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地理解和使用它。

目录#

  1. 基础概念
    • switch 表达式中的 yield
    • Thread.yield() 方法
  2. 使用方法
    • switch 表达式中 yield 的使用
    • Thread.yield() 方法的使用
  3. 常见实践
    • switch 表达式的实际应用
    • 多线程编程中的 yield
  4. 最佳实践
    • switch 表达式的最佳使用方式
    • 多线程编程中 yield 的使用建议
  5. 小结
  6. 参考资料

基础概念#

switch 表达式中的 yield#

在 Java 13 及以后的版本中，引入了 switch 表达式，yield 关键字用于在 switch 表达式中返回一个值。与传统的 switch 语句不同，switch 表达式可以作为一个值进行赋值或传递。

Thread.yield() 方法#

Thread.yield() 是 Thread 类的一个静态方法。当一个线程调用 yield() 方法时，它会暗示调度器当前线程愿意让出 CPU 时间片，让其他具有相同优先级的线程有机会执行。但这只是一个暗示，调度器可以选择忽略它。

使用方法#

switch 表达式中 yield 的使用#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class SwitchYieldExample {
    public static void main(String[] args) {
        int num = 2;
        String result = switch (num) {
            case 1 -> "One";
            case 2 -> {
                // 可以在代码块中使用 yield 返回值
                System.out.println("Processing case 2");
                yield "Two";
            }
            default -> "Other";
        };
        System.out.println(result);
    }
}

 

在上述代码中，当 num 为 2 时，会执行代码块中的内容，最后使用 yield 关键字返回 "Two"。

Thread.yield() 方法的使用#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class YieldThread extends Thread {
    public YieldThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            // 调用 yield 方法让出 CPU 时间片
            Thread.yield();
        }
    }
}
public class ThreadYieldExample {
    public static void main(String[] args) {
        YieldThread thread1 = new YieldThread("Thread 1");
        YieldThread thread2 = new YieldThread("Thread 2");
        thread1.start();
        thread2.start();
    }
}

在上述代码中，YieldThread 类继承自 Thread 类，在 run 方法中，每次循环都会调用 Thread.yield() 方法，暗示调度器让出 CPU 时间片。

常见实践#

switch 表达式的实际应用#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class SwitchYieldPracticalExample {
    public static String getDayOfWeek(int day) {
        return switch (day) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            case 3 -> "Wednesday";
            case 4 -> "Thursday";
            case 5 -> "Friday";
            case 6 -> "Saturday";
            case 7 -> "Sunday";
            default -> {
                System.out.println("Invalid day");
                yield "Invalid";
            }
        };
    }
    public static void main(String[] args) {
        int day = 3;
        String dayName = getDayOfWeek(day);
        System.out.println(dayName);
    }
}

在上述代码中，getDayOfWeek 方法根据传入的数字返回对应的星期几，使用 switch 表达式和 yield 关键字实现了简洁的逻辑。

多线程编程中的 yield#

在多线程编程中，yield 方法可以用于优化线程调度，避免某个线程长时间占用 CPU。例如，在一个生产者 – 消费者模型中，生产者线程在生产数据时可以适当调用 yield 方法，让消费者线程有更多机会处理数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import java.util.LinkedList;
import java.util.Queue;
class Producer extends Thread {
    private Queue<Integer> queue;
    private int maxSize;
    public Producer(Queue<Integer> queue, int maxSize, String name) {
        super(name);
        this.queue = queue;
        this.maxSize = maxSize;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            synchronized (queue) {
                while (queue.size() == maxSize) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                queue.add(i);
                System.out.println("Produced: " + i);
                queue.notifyAll();
            }
            // 让出 CPU 时间片
            Thread.yield();
        }
    }
}
class Consumer extends Thread {
    private Queue<Integer> queue;
    public Consumer(Queue<Integer> queue, String name) {
        super(name);
        this.queue = queue;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int item = queue.poll();
                System.out.println("Consumed: " + item);
                queue.notifyAll();
            }
            // 让出 CPU 时间片
            Thread.yield();
        }
    }
}
public class ProducerConsumerYieldExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        int maxSize = 5;
        Producer producer = new Producer(queue, maxSize, "Producer");
        Consumer consumer = new Consumer(queue, "Consumer");
        producer.start();
        consumer.start();
    }
}

在上述代码中，生产者线程和消费者线程在适当的时候调用 Thread.yield() 方法，让对方线程有更多机会执行。

最佳实践#

switch 表达式的最佳使用方式#

  • 当 case 分支逻辑简单时，使用箭头 -> 语法；当逻辑复杂时，使用代码块和 yield 关键字。
  • 确保 switch 表达式覆盖所有可能的情况，使用 default 分支处理未预料到的情况。

多线程编程中 yield 的使用建议#

  • yield 方法只是一个暗示，不能保证线程一定会让出 CPU 时间片。
  • 不要过度依赖 yield 方法来解决线程调度问题，应该优先考虑使用同步机制（如 synchronized 关键字、Lock 接口）和线程协作机制（如 wait()、notify()、notifyAll()）。

小结#

本文详细介绍了 Java 中 yield 关键字的两种主要用途：在 switch 表达式中返回值和在多线程编程中让出 CPU 时间片。通过代码示例和常见实践，展示了 yield 关键字的使用方法和应用场景。同时，给出了最佳实践建议，帮助读者更好地使用 yield 关键字。

参考资料#

  • Java 官方文档
  • 《Effective Java》
  • 《Java 核心技术》

 

from:https://javaguidepro.com/blog/yield-java/

Copyright © 2026 Longsheng All rights reserved