Java并发编程：使用ExecutorService限制并发线程数

import com.google.gson.Gson;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.nio.file.Path;
import java.util.Objects;

// 模拟的业务实体和DAO层，用于使SerializationTask独立可运行
class EventuelleDestination {
    private String name;
    private EventuelAcceuillant eventuelAcceuillant;

    public EventuelleDestination(String name, EventuelAcceuillant acceuillant) {
        this.name = name;
        this.eventuelAcceuillant = acceuillant;
    }
    public EventuelAcceuillant getEventuelAcceuillant() { return eventuelAcceuillant; }
    @Override
    public String toString() { return "EventuelleDestination{" + "name='" + name + '\'' + '}'; }
}

class EventuelAcceuillant {
    private int id;
    public EventuelAcceuillant(int id) { this.id = id; }
    public int getId() { return id; }
}

class EmployeDao {
    public Employe getEmploye() { return new Employe(1001); } // 模拟获取员工
}

class Employe {
    private int id;
    public Employe(int id) { this.id = id; }
    public int getId() { return id; }
}

class EntrepriseDao {
    public int retrouveEmplacementIdParDepartementId(int deptId) { return deptId * 10; } // 模拟获取位置ID
}

/**
 * 负责将EventuelleDestination对象序列化到文件的Runnable任务。
 */
public class SerializationTask implements Runnable {
    private final EventuelleDestination eventuelleDestination;
    private final Path dossierSoumissions; // 序列化输出的基础目录
    private final EmployeDao employeDao;
    private final EntrepriseDao entrepriseDao;

    public SerializationTask(EventuelleDestination e, Path dossierSoumissions, EmployeDao employeDao, EntrepriseDao entrepriseDao) {
        this.eventuelleDestination = Objects.requireNonNull(e, "EventuelleDestination cannot be null");
        this.dossierSoumissions = Objects.requireNonNull(dossierSoumissions, "DossierSoumissions path cannot be null");
        this.employeDao = Objects.requireNonNull(employeDao, "EmployeDao cannot be null");
        this.entrepriseDao = Objects.requireNonNull(entrepriseDao, "EntrepriseDao cannot be null");
    }

    @Override
    public void run() {
        Gson gson = new Gson();
        // 根据业务逻辑构建文件名
        String filename = "/" + employeDao.getEmploye().getId() + "_" +
                          entrepriseDao.retrouveEmplacementIdParDepartementId(eventuelleDestination.getEventuelAcceuillant().getId()) + "_" +
                          eventuelleDestination.getEventuelAcceuillant().getId() + ".json";

        try (Writer writer = new FileWriter(dossierSoumissions.resolve(filename).toString())) {
            gson.toJson(eventuelleDestination, writer);
            System.out.println(Thread.currentThread().getName() + ": " + eventuelleDestination + " 已序列化到 " + filename + "...");
        } catch (IOException e) {
            System.err.println(Thread.currentThread().getName() + ": 序列化 " + eventuelleDestination + " 时发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.io.IOException;

public class FixedThreadPoolDemo {

    private final Path tempDir; // 用于存储序列化文件的临时目录
    private final EmployeDao employeDao = new EmployeDao();
    private final EntrepriseDao entrepriseDao = new EntrepriseDao();

    public FixedThreadPoolDemo() throws IOException {
        // 创建一个临时目录用于序列化输出，确保示例的整洁性
        this.tempDir = Files.createTempDirectory("serialization_output");
        System.out.println("序列化输出目录: " + tempDir.toAbsolutePath());
    }

    public void runDemo() {
        List<EventuelleDestination> destinations = new ArrayList<>();
        // 填充一些模拟数据，共10个任务
        for (int i = 1; i <= 10; i++) {
            destinations.add(new EventuelleDestination("Destination_" + i, new EventuelAcceuillant(i)));
        }

        // 定义固定线程池的大小，这里设置为3，与问题要求一致
        final int THREAD_POOL_SIZE = 3;
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
        System.out.println("开始使用固定大小为 " + THREAD_POOL_SIZE + " 的线程池进行序列化。");

        // 遍历列表，将每个序列化任务提交给线程池
        for (EventuelleDestination dest : destinations) {
            executorService.submit(new SerializationTask(dest, tempDir, employeDao, entrepriseDao));
        }

        // 优雅地关闭线程池
        shutdownAndAwaitTermination(executorService);
        System.out.println("所有序列化任务已完成或终止。输出文件位于: " + tempDir.toAbsolutePath());

        // 清理临时目录（可选）
        try {
            Files.walk(tempDir)
                 .sorted(java.util.Comparator.reverseOrder()) // 先删除文件，再删除空目录
                 .map(Path::toFile)
                 .forEach(java.io.File::delete);
            Files.delete(tempDir);
            System.out.println("已清理临时目录: " + tempDir.toAbsolutePath());
        } catch (IOException e) {
            System.err.println("清理临时目录时发生错误: " + e.getMessage());
        }
    }

    /**
     * 优雅地关闭ExecutorService的工具方法。
     * 参照JavaDoc中的最佳实践。
     */
    void shutdownAndAwaitTermination(ExecutorService pool) {
        pool.shutdown(); // 停止接收新任务
        try {
            // 等待已提交任务完成，最多等待60秒
            if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                pool.shutdownNow(); // 强制取消当前正在执行的任务
                // 再次等待，确保任务响应中断
                if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                    System.err.println("执行器服务未能终止。 " + Instant.now());
                }
            }
        } catch (InterruptedException ex) {
            // 如果当前线程在等待期间被中断，则重新取消所有任务
            pool.shutdownNow();
            // 保留中断状态
            Thread.currentThread().interrupt