BlockingQueue通过阻塞机制实现线程安全的任务调度，适用于生产者-消费者模型。1. 根据需求选择ArrayBlockingQueue（有界数组队列）、LinkedBlockingQueue（高吞吐链表队列）、PriorityBlockingQueue（优先级调度）或DelayQueue（延迟任务）。2. 可自定义TaskScheduler封装BlockingQueue，由工作线程调用take()获取任务并执行，submit()提交任务时自动阻塞等待空位。3. 推荐使用ExecutorService简化管理，如ThreadPoolExecutor结合ArrayBlockingQueue实现固定线程池任务调度。4. 对于定时任务，可实现Delayed接口创建DelayedTask类，利用DelayQueue存储并在延迟到期后取出执行。最终需注意合理关闭线程与释放资源。
在Java中，BlockingQueue 是实现任务调度的一种高效且线程安全的方式，常用于生产者-消费者模型。它能自动处理线程间的协调，比如当队列满时阻塞生产者，队列空时阻塞消费者，非常适合用在多线程任务调度场景中。
1. 选择合适的BlockingQueue实现类
根据调度需求选择不同的 BlockingQueue 实现：
- ArrayBlockingQueue：基于数组的有界队列，适合固定大小的任务池。
- LinkedBlockingQueue：基于链表的可选有界队列，吞吐量通常更高。
- PriorityBlockingQueue：支持优先级排序的任务调度，适用于需要优先执行某些任务的场景。
- DelayQueue：元素只有在延迟期满后才能被取出，适合定时任务调度。
2. 创建任务调度的基本结构
定义一个任务（Runnable 或 Callable），然后通过生产者线程提交任务到 BlockingQueue，消费者线程从队列中取出并执行。
示例代码：
import java.util.concurrent.*;
<p>public class TaskScheduler {
private final BlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>(100);
private final Thread worker;</p><pre class='brush:java;toolbar:false;'>public TaskScheduler() {
worker = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
try {
// take() 方法会阻塞直到有任务到来
Runnable task = taskQueue.take();
task.run();
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 恢复中断状态
break;
}
}
});
worker.start();
}
// 提交任务
public void submit(Runnable task) {
try {
taskQueue.put(task); // 队列满时会阻塞
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
// 关闭调度器
public void shutdown() {
worker.interrupt();
}}
立即学习“Java免费学习笔记（深入）”；
3. 使用线程池简化调度管理
Java 提供了 ExecutorService，其底层正是使用 BlockingQueue 来调度任务，推荐直接使用以减少出错。
// 使用 ThreadPoolExecutor 自定义任务队列
BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
ExecutorService executor = new ThreadPoolExecutor(
2, 2, 0L, TimeUnit.MILLISECONDS, queue);
<p>// 提交任务
executor.submit(() -> System.out.println("执行任务"));</p><p>// 关闭线程池
executor.shutdown();</p>4. 延迟/定时任务调度（使用 DelayQueue）
若需延迟执行任务，可自定义任务类实现 Delayed 接口。
class DelayedTask implements Runnable, Delayed {
private final long delayTime; // 延迟时间（毫秒）
private final Runnable task;
private final long submitTime = System.currentTimeMillis();
<pre class='brush:java;toolbar:false;'>public DelayedTask(long delay, Runnable task) {
this.delayTime = delay;
this.task = task;
}
@Override
public long getDelay(TimeUnit unit) {
long diff = submitTime + delayTime - System.currentTimeMillis();
return unit.convert(diff, TimeUnit.MILLISECONDS);
}
@Override
public int compareTo(Delayed o) {
return Long.compare(this.getDelay(TimeUnit.MILLISECONDS),
o.getDelay(TimeUnit.MILLISECONDS));
}
@Override
public void run() {
task.run();
}}
立即学习“Java免费学习笔记（深入）”；
// 调度延迟任务 BlockingQueue<Delayed> delayQueue = new DelayQueue<>(); Thread scheduler = new Thread(() -> { while (!Thread.currentThread().isInterrupted()) { try { DelayedTask task = (DelayedTask) delayQueue.take(); new Thread(task).start(); // 执行任务 } catch (InterruptedException e) { break; } } }); scheduler.start();
// 提交一个5秒后执行的任务 delayQueue.put(new DelayedTask(5000, () -> System.out.println("延迟任务执行")));
基本上就这些。BlockingQueue 让任务调度变得简单可靠，关键是根据场景选择合适的队列类型，并注意线程安全与资源释放。
