Java多线程实现之线程调度详解

- 一、线程调度基础概念
- - [1.1 线程调度器](#1.1 线程调度器)
  - [1.2 时间片](#1.2 时间片)
  - [1.3 线程状态转换](#1.3 线程状态转换)
- 二、线程优先级
- - [2.1 优先级范围](#2.1 优先级范围)
  - [2.2 设置线程优先级](#2.2 设置线程优先级)
  - [2.3 优先级注意事项](#2.3 优先级注意事项)
- 三、线程调度方法
- - [3.1 Thread.sleep(long millis)](#3.1 Thread.sleep(long millis))
  - [3.2 Thread.yield()](#3.2 Thread.yield())
  - [3.3 Thread.join()](#3.3 Thread.join())
  - [3.4 Object.wait() / notify() / notifyAll()](#3.4 Object.wait() / notify() / notifyAll())
- 四、线程调度策略
- - [4.1 抢占式调度](#4.1 抢占式调度)
  - [4.2 公平锁与非公平锁](#4.2 公平锁与非公平锁)
  - [4.3 守护线程](#4.3 守护线程)
- 五、线程池中的调度
- - [5.1 线程池的调度策略](#5.1 线程池的调度策略)
  - [5.2 自定义线程池调度](#5.2 自定义线程池调度)
- 六、线程调度的最佳实践
- - [6.1 避免过度依赖优先级](#6.1 避免过度依赖优先级)
  - [6.2 合理使用sleep和yield](#6.2 合理使用sleep和yield)
  - [6.3 优先使用线程池](#6.3 优先使用线程池)
  - [6.4 正确处理线程中断](#6.4 正确处理线程中断)
- 总结

Java多线程中线程调度是一个核心概念，它决定了线程如何获得CPU资源并执行。合理的线程调度策略能够充分发挥多核处理器的性能，提高程序的执行效率。本文我将深入探讨Java线程调度的原理、机制以及相关的API，带你更好地理解和控制线程的执行。

一、线程调度基础概念

1.1 线程调度器

线程调度器是JVM的一部分，负责决定哪个线程获得CPU时间片以及执行多长时间。Java线程调度器采用抢占式调度模型，即高优先级的线程可以抢占低优先级线程的CPU资源。

1.2 时间片

时间片是线程在CPU上执行的最小时间单位。调度器会为每个线程分配一个时间片，当时间片用完后，该线程会被暂停执行，调度器会选择另一个线程执行。

1.3 线程状态转换

线程在其生命周期中会经历多种状态，调度器在这些状态之间进行转换：

新建(New)：线程被创建但尚未启动
就绪(Runnable)：线程正在等待CPU资源
运行(Running)：线程正在CPU上执行
阻塞(Blocked)：线程因等待锁、IO等原因暂停执行
等待(Waiting)：线程等待其他线程通知
超时等待(Timed Waiting)：线程在指定时间内等待
终止(Terminated)：线程执行完毕或异常终止

二、线程优先级

2.1 优先级范围

Java线程优先级范围从1到10，数值越大优先级越高：

Thread.MIN_PRIORITY = 1
Thread.NORM_PRIORITY = 5（默认优先级）
Thread.MAX_PRIORITY = 10

2.2 设置线程优先级

通过setPriority(int priority)方法设置线程优先级：

java 复制代码

Thread highPriorityThread = new Thread(() -> {
    // 高优先级线程任务
});
highPriorityThread.setPriority(Thread.MAX_PRIORITY);

Thread lowPriorityThread = new Thread(() -> {
    // 低优先级线程任务
});
lowPriorityThread.setPriority(Thread.MIN_PRIORITY);

2.3 优先级注意事项

优先级不保证执行顺序：高优先级线程只是更有可能获得CPU资源，但不保证一定先执行
平台依赖性：不同操作系统对线程优先级的支持不同，可能导致优先级行为不一致
避免过度依赖优先级：应通过合理的同步机制而非优先级来控制线程执行顺序

三、线程调度方法

3.1 Thread.sleep(long millis)

使当前线程暂停执行指定的毫秒数，线程进入超时等待状态：

java 复制代码

try {
    Thread.sleep(1000); // 暂停1秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

3.2 Thread.yield()

提示调度器当前线程愿意让出CPU资源，线程进入就绪状态：

java 复制代码

public void run() {
    for (int i = 0; i < 100; i++) {
        // 执行一些工作
        if (i % 10 == 0) {
            Thread.yield(); // 让出CPU资源
        }
    }
}

3.3 Thread.join()

等待指定线程执行完毕：

java 复制代码

Thread t = new Thread(() -> {
    // 执行耗时操作
});
t.start();

try {
    t.join(); // 等待线程t执行完毕
} catch (InterruptedException e) {
    e.printStackTrace();
}

3.4 Object.wait() / notify() / notifyAll()

用于线程间通信，实现线程的协作：

java 复制代码

class SharedResource {
    private boolean ready = false;
    
    public synchronized void waitForReady() throws InterruptedException {
        while (!ready) {
            wait(); // 线程等待
        }
    }
    
    public synchronized void setReady() {
        ready = true;
        notifyAll(); // 唤醒所有等待的线程
    }
}

四、线程调度策略

4.1 抢占式调度

Java默认采用抢占式调度，高优先级线程可以抢占低优先级线程的CPU资源。但这种抢占不是绝对的，具体还取决于操作系统的调度策略。

4.2 公平锁与非公平锁

公平锁：线程按照请求锁的顺序获得锁，保证公平性但可能降低吞吐量
非公平锁：允许线程在锁释放时直接竞争，可能导致某些线程长期得不到锁

4.3 守护线程

守护线程是为其他线程提供服务的线程，当所有非守护线程结束时，JVM会自动终止守护线程：

java 复制代码

Thread daemonThread = new Thread(() -> {
    // 守护线程任务
});
daemonThread.setDaemon(true); // 设置为守护线程
daemonThread.start();

五、线程池中的调度

5.1 线程池的调度策略

线程池通过ExecutorService接口提供，常见的线程池实现有：

FixedThreadPool：固定大小的线程池
CachedThreadPool：可缓存的线程池
ScheduledThreadPool：支持定时任务的线程池

5.2 自定义线程池调度

通过ThreadPoolExecutor可以自定义线程池的调度策略：

java 复制代码

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5,                   // 核心线程数
    10,                  // 最大线程数
    60,                  // 空闲线程存活时间
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100),  // 任务队列
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
);

六、线程调度的最佳实践

6.1 避免过度依赖优先级

线程优先级应谨慎使用，过度依赖优先级可能导致程序行为不稳定，尤其是在不同操作系统上。

6.2 合理使用sleep和yield

sleep()用于精确控制线程暂停时间
yield()用于提示调度器让出CPU资源，但不保证一定会让出

6.3 优先使用线程池

线程池提供了更高级的调度控制和资源管理，应优先使用线程池而非手动创建线程。

6.4 正确处理线程中断

在线程中正确处理InterruptedException，确保线程可以被优雅地终止：

java 复制代码

public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        // 线程任务
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断状态
            break;
        }
    }
}

总结

Java线程调度是一个复杂的机制，涉及优先级、状态转换、同步等多个方面，理解线程调度的原理和机制，能够帮助我们更好地控制线程执行，提高程序性能和稳定性，实际开发中我们应遵循最佳实践，合理使用线程调度相关的API，通过线程池、同步机制等工具，构建出高效、健壮的多线程应用程序。

若这篇内容帮到你，动动手指支持下！关注不迷路，干货持续输出！

ヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉ