Java多线程任务调度：高效处理共享任务列表的策略

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TaskDispatcherWithExecutorService {

    public static void main(String[] args) {
        // 定义任务列表
        List<String> tasks = Arrays.asList(
            "firstTask", "secondTask", "thirdTask", "fourthTask", "fifthTask",
            "sixthTask", "seventhTask", "eighthTask", "ninthTask", "tenthTask"
        );

        // 创建一个固定大小为3的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        System.out.println("开始分发任务...");

        // 遍历任务列表，将每个任务提交给ExecutorService
        for (String taskName : tasks) {
            executor.submit(() -> {
                try {
                    // 模拟任务执行时间
                    long duration = (long) (Math.random() * 2000) + 500; // 0.5s to 2.5s
                    System.out.println(Thread.currentThread().getName() + " 正在执行任务: " + taskName + " (耗时: " + duration + "ms)");
                    Thread.sleep(duration);
                    System.out.println(Thread.currentThread().getName() + " 完成任务: " + taskName);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.err.println(Thread.currentThread().getName() + " 任务 " + taskName + " 被中断。");
                }
            });
        }

        // 关闭ExecutorService
        // shutdown()方法会平滑地关闭ExecutorService，不再接受新任务，但会等待已提交任务完成
        executor.shutdown();

        try {
            // 等待所有任务完成，最多等待10秒
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                System.err.println("部分任务未能在指定时间内完成，强制关闭。");
                // shutdownNow()会尝试中断正在执行的任务，并清空任务队列
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            System.err.println("等待任务完成时被中断，强制关闭。");
        }

        System.out.println("所有任务分发和执行完毕。");
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class TaskDispatcherWithBlockingQueue {

    public static void main(String[] args) throws InterruptedException {
        // 创建一个容量为10的阻塞队列
        BlockingQueue<String> taskQueue = new LinkedBlockingQueue<>(10);

        // 生产者线程：模拟任务的生成和放入队列
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    String task = "Task-" + i;
                    System.out.println("生产者: 放入任务 " + task);
                    taskQueue.put(task); // 放入任务，如果队列满则阻塞
                    Thread.sleep(200); // 模拟生产任务的时间
                }
                // 放入一个结束标志，通知消费者没有更多任务了
                taskQueue.put("END");
                System.out.println("生产者: 所有任务已放入队列。");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println("生产者被中断。");
            }
        }, "ProducerThread");

        // 消费者线程：模拟任务的获取和执行
        Runnable consumerTask = () -> {
            try {
                while (true) {
                    String task = taskQueue.take(); // 取出任务，如果队列空则阻塞
                    if ("END".equals(task)) {
                        // 重新放入END标志，以便其他消费者也能接收到结束信号
                        taskQueue.put("END");
                        System.out.println(Thread.currentThread().getName() + ": 接收到结束信号，退出。");
                        break;
                    }
                    // 模拟任务执行
                    long duration = (long) (Math.random() * 1000) + 200;
                    System.out.println(Thread.currentThread().getName() + " 正在执行任务: " + task + " (耗时: " + duration + "ms)");
                    Thread.sleep(duration);
                    System.out.println(Thread.currentThread().getName() + " 完成任务: " + task);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println(Thread.currentThread().getName() + ": 消费者被中断。");
            }
        };

        // 创建并启动多个消费者线程
        Thread consumer1 = new Thread(consumerTask, "Consumer-1");
        Thread consumer2 = new Thread(consumerTask, "Consumer-2");
        Thread consumer3 = new Thread(consumerTask, "Consumer-3");

        producer.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();

        // 等待所有线程完成
        producer.join();
        consumer1.join();
        consumer2.join();
        consumer3.join();

        System.out.println("所有生产者和消费者任务完成。");
    }
}