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 TaskProcessor {

    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) {
            // 将每个字符串任务封装为一个Runnable
            Runnable worker = new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName() + " 正在处理任务: " + taskName);
                        // 模拟任务执行时间
                        Thread.sleep((long) (Math.random() * 1000));
                        System.out.println(Thread.currentThread().getName() + " 完成任务: " + taskName);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt(); // 重新设置中断状态
                        System.err.println(Thread.currentThread().getName() + " 任务 " + taskName + " 被中断。");
                    }
                }
            };
            executor.submit(worker); // 提交任务
        }

        System.out.println("--- 所有任务已提交，等待执行完成 ---");

        // 关闭ExecutorService，等待所有已提交任务完成
        executor.shutdown(); // 不再接受新任务
        try {
            // 等待所有任务在指定时间内完成
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                System.err.println("部分任务未在规定时间内完成，强制关闭。");
                executor.shutdownNow(); // 强制关闭所有正在执行的任务
            }
        } catch (InterruptedException e) {
            System.err.println("等待任务完成时被中断。");
            executor.shutdownNow();
        }
        System.out.println("--- 所有任务执行完毕 ---");
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public class ManualTaskProcessor {

    private static final int NUM_THREADS = 3;
    private static final BlockingQueue<String> taskQueue = new LinkedBlockingQueue<>();
    private static final AtomicInteger tasksCompleted = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        List<String> tasks = Arrays.asList(
            "firstTask", "secondTask", "thirdTask", "fourthTask", "fifthTask",
            "sixthTask", "seventhTask", "eighthTask", "ninthTask", "tenthTask"
        );

        // 生产者：将所有任务放入队列
        for (String taskName : tasks) {
            taskQueue.put(taskName); // put() 方法会阻塞直到有空间可用
        }

        // 消费者：创建并启动工作线程
        Thread[] workerThreads = new Thread[NUM_THREADS];
        for (int i = 0; i < NUM_THREADS; i++) {
            workerThreads[i] = new Thread(() -> {
                try {
                    while (true) {
                        // take() 方法会阻塞直到队列中有元素可用
                        String task = taskQueue.take();
                        if ("POISON_PILL".equals(task)) { // 毒丸机制，用于优雅关闭线程
                            taskQueue.put(task); // 将毒丸放回队列，让其他线程也能收到
                            break;
                        }
                        System.out.println(Thread.currentThread().getName() + " 正在处理任务: " + task);
                        Thread.sleep((long) (Math.random() * 1000)); // 模拟任务执行
                        System.out.println(Thread.currentThread().getName() + " 完成任务: " + task);
                        tasksCompleted.incrementAndGet();
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.err.println(Thread.currentThread().getName() + " 被中断。");
                }
            }, "Worker-" + (i + 1));
            workerThreads[i].start();
        }

        // 等待所有任务完成
        while (tasksCompleted.get() < tasks.size()) {
            Thread.sleep(100); // 短暂等待
        }

        // 发送“毒丸”信号，通知所有工作线程退出
        for (int i = 0; i < NUM_THREADS; i++) {
            taskQueue.put("POISON_PILL");
        }

        // 等待所有工作线程结束
        for (Thread thread : workerThreads) {
            thread.join();
        }

        System.out.println("--- 所有任务执行完毕 ---");
    }
}