线程数少于 corePoolSize
    → 尝试创建工作线程执行任务

否则，队列能够接收
    → 任务进入等待队列

否则，线程数少于 maximumPoolSize
    → 尝试创建更多线程执行任务

再无法接收
    → 执行拒绝策略

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    static void await(CountDownLatch latch) throws InterruptedException {
        if (!latch.await(5, TimeUnit.SECONDS)) {
            throw new IllegalStateException("wait timeout");
        }
    }

    static Runnable task(int id, CountDownLatch firstStarted,
                         CountDownLatch twoRunning, CountDownLatch release,
                         ConcurrentLinkedQueue<Integer> completed,
                         ConcurrentLinkedQueue<Throwable> failures) {
        return () -> {
            firstStarted.countDown();
            twoRunning.countDown();
            try {
                await(release);
                completed.add(id);
            } catch (InterruptedException exception) {
                Thread.currentThread().interrupt();
                failures.add(exception);
            } catch (RuntimeException exception) {
                failures.add(exception);
            }
        };
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicInteger threadId = new AtomicInteger();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1, 2, 30, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                action -> new Thread(action, "demo-worker-" + threadId.incrementAndGet()),
                new ThreadPoolExecutor.AbortPolicy());

        CountDownLatch firstStarted = new CountDownLatch(1);
        CountDownLatch twoRunning = new CountDownLatch(2);
        CountDownLatch release = new CountDownLatch(1);
        ConcurrentLinkedQueue<Integer> completed = new ConcurrentLinkedQueue<>();
        ConcurrentLinkedQueue<Throwable> failures = new ConcurrentLinkedQueue<>();

        try {
            executor.execute(task(1, firstStarted, twoRunning, release, completed, failures));
            await(firstStarted);
            executor.execute(task(2, firstStarted, twoRunning, release, completed, failures));
            executor.execute(task(3, firstStarted, twoRunning, release, completed, failures));
            await(twoRunning);

            System.out.println("workers = " + executor.getPoolSize());
            System.out.println("queued = " + executor.getQueue().size());

            try {
                executor.execute(task(4, firstStarted, twoRunning, release, completed, failures));
            } catch (RejectedExecutionException exception) {
                System.out.println("task 4 = rejected");
            }
        } finally {
            release.countDown();
            executor.shutdown();
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                throw new IllegalStateException("shutdown timeout");
            }
        }

        if (!failures.isEmpty()) {
            throw new IllegalStateException("task failed", failures.peek());
        }
        List<Integer> result = new ArrayList<>(completed);
        Collections.sort(result);
        System.out.println("completed tasks = " + result);
    }
}

workers = 2
queued = 1
task 4 = rejected
completed tasks = [1, 2, 3]

用户资料 ─┐
          ├── thenCombine → 页面结果
订单数量 ─┘