如何创建线程池

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

import java.util.concurrent.*;

public class ThreadPoolRejectDemo {
    public static void main(String[] args) {
        // 核心线程数=1，最大线程数=1，队列容量=1（容易触发饱和策略）
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1, 1,
                0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(1), // 有界队列，容量1
                new ThreadPoolExecutor.CallerRunsPolicy() // 指定饱和策略为CallerRunsPolicy
        );

        // 提交3个任务，触发饱和策略（核心线程1个，队列1个，第3个触发）
        for (int i = 0; i < 3; i++) {
            int taskId = i;
            executor.submit(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println("任务" + taskId + "执行，执行线程：" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        executor.shutdown();
    }
}

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.logging.Logger;

// 自定义饱和策略：记录日志 + 尝试重试提交
class CustomRejectPolicy implements RejectedExecutionHandler {
    private static final Logger logger = Logger.getLogger(CustomRejectPolicy.class.getName());
    private int retryTimes = 3; // 重试次数
    private long retryInterval = 100; // 重试间隔（毫秒）

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        int count = 0;
        // 未关闭线程池且未重试完，就尝试重新提交
        while (!executor.isShutdown() && count < retryTimes) {
            try {
                logger.info("任务提交失败，重试第" + (count + 1) + "次");
                // 尝试将任务重新加入线程池
                executor.execute(r);
                return; // 重试成功，退出
            } catch (RejectedExecutionException e) {
                count++;
                try {
                    Thread.sleep(retryInterval);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
        // 重试失败，记录错误日志
        logger.severe("任务重试" + retryTimes + "次仍失败，任务被丢弃：" + r.toString());
    }
}

// 使用自定义策略
public class CustomRejectDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1, 1,
                0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(1),
                new CustomRejectPolicy() // 自定义策略
        );

        // 提交3个任务触发重试
        for (int i = 0; i < 3; i++) {
            int taskId = i;
            executor.execute(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println("任务" + taskId + "执行");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        executor.shutdown();
    }
}

package thread.learn.executor;

import java.util.Date;

public class MyRunner implements Runnable {

    private String command;

    public MyRunner(String command) {
        this.command = command;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return this.command;
    }
}

package thread.learn.executor;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorDemo {

    private static final int CORE_POOL_SIZE = 5;
    private static final int MAX_POOL_SIZE = 10;
    private static final int QUEUE_CAPACITY = 100;
    private static final long KEEP_ALIVE_TIME = 1L;

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, new ArrayBlockingQueue<>(QUEUE_CAPACITY), new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 10; i++) {
            MyRunner worker = new MyRunner("" + i);
            executor.execute(worker);
        }
        executor.shutdown();
        while (!executor.isTerminated()) {
            // Wait for all tasks to complete
        }
        System.out.println("Finished all threads");
    }

}