Java 线程池 execute() 与 submit() 方法区别及源码解析

2.2 execute() 的核心逻辑

// ThreadPoolExecutor.java
public void execute(Runnable command) {
    if (command == null) throw new NullPointerException();
    int c = ctl.get();
    // 1. workerCount < corePoolSize -> 创建核心线程
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true)) return;
        c = ctl.get();
    }
    // 2. workerCount >= corePoolSize && workQueue 未满 -> 入队
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (!isRunning(recheck) && remove(command)) reject(command);
        else if (workerCountOf(recheck) == 0) addWorker(null, false);
    }
    // 3. workerCount >= corePoolSize && workQueue 已满 -> 创建非核心线程
    else if (!addWorker(command, false))
        // 4. 都失败 -> 拒绝策略
        reject(command);
}

执行流程：

• 工作线程数 < 核心线程数 → 创建核心线程执行
• 工作线程数 ≥ 核心线程数，队列未满 → 任务入队
• 工作线程数 ≥ 核心线程数，队列已满 → 创建非核心线程
• 都失败 → 触发拒绝策略

三、实战场景对比

3.1 异常处理的根本差异

execute() 的异常陷阱：

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(() -> {
    throw new RuntimeException("任务异常");
});
// 主线程无法捕获这个异常！
// 异常会直接抛出到线程池的 UncaughtExceptionHandler

submit() 的异常安全：

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<?> future = executor.submit(() -> {
    throw new RuntimeException("任务异常");
});
try {
    future.get(); // 调用 get() 时才会抛出 ExecutionException
} catch (ExecutionException e) {
    System.out.println("捕获到任务异常：" + e.getCause());
}

3.2 批量任务处理 - submit 优势场景

ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future<Integer>> futures = new ArrayList<>();
// 提交多个任务
for (int i = 0; i < 10; i++) {
    final int num = i;
    futures.add(executor.submit(() -> compute(num)));
}
// 批量获取结果
for (Future<Integer> future : futures) {
    try {
        System.out.println(future.get());
    } catch (Exception e) {
        System.out.println("任务执行异常：" + e.getCause());
    }
}

private int compute(int num) {
    // 模拟计算任务
    return num * num;
}

3.3 超时控制 - submit 独有能力

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<String> future = executor.submit(() -> {
    Thread.sleep(5000);
    return "结果";
});
try {
    String result = future.get(2, TimeUnit.SECONDS); // 2 秒超时
    System.out.println(result);
} catch (TimeoutException e) {
    future.cancel(true); // 中断任务
    System.out.println("任务超时，已取消");
}

3.4 execute 的最佳实践 - 异常监控

// 设置全局异常处理器
Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
    System.out.println("线程 " + t.getName() + " 发生异常：" + e);
});
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(() -> {
    throw new RuntimeException("异常会被 UncaughtExceptionHandler 捕获");
});

四、性能考量

• execute()：略轻量，直接提交任务，无需创建 FutureTask 对象
• submit()：因创建 FutureTask 有极小开销，但在实际业务中差异可忽略
• 建议：如果不需要返回值和异常处理，优先使用 execute()

五、面试标准答案

问题： Java 线程池中 execute() 和 submit() 有什么区别？

标准回答：

1. 核心差异：execute() 是 Executor 接口定义的基础方法，用于提交不需要返回值的任务；submit() 是 ExecutorService 扩展的方法，可以提交 Callable/Runnable 并返回 Future 对象。
2. 源码层面：submit() 内部将任务包装成 FutureTask，然后调用 execute() 执行，所以 execute() 是 submit() 的底层实现。
3. 异常处理：这是最重要的区别——execute() 中任务的异常会直接抛出到线程池的异常处理器，主线程无法感知；submit() 中任务的异常被 FutureTask 捕获存储，只有调用 Future.get() 时才会抛出 ExecutionException，主线程可以统一处理。
4. 适用场景：execute() 适合'提交即忘'的异步任务（如日志、清理）；submit() 适合需要结果、超时控制或细粒度异常处理的任务。
5. 性能考量：execute() 略轻量，submit() 因为创建 FutureTask 有极小开销，但在实际业务中差异可忽略。

六、进阶思考

6.1 为什么 submit() 要返回 Future？

这是'控制权'的设计哲学，调用者可以通过 Future 实现取消、超时、结果获取等精细控制。

6.2 线程池的拒绝策略对两者有区别吗？

没有，最终都是调用 execute()，拒绝策略统一生效。

6.3 如何既用 execute() 的轻量，又实现异常监控？

可以自定义 ThreadPoolExecutor，重写 afterExecute() 方法：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>()) {
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t != null) {
            System.out.println("任务执行异常：" + t);
        } else if (r instanceof Future<?>) {
            try {
                ((Future<?>) r).get();
            } catch (Exception e) {
                System.out.println("Future 异常：" + e.getCause());
            }
        }
    }
};

七、总结

这道题的深层考点是：是否理解 Java 并发框架中'任务'和'执行'的分离设计，以及异常在不同线程上下文中的传播机制。

• execute()：轻量级异步执行，适合'提交即忘'场景
• submit()：功能完善，支持结果获取、超时控制、异常统一处理

选择建议：

• 不需要返回值 → 优先 execute()
• 需要返回值或异常处理 → 必须使用 submit()