Java线程池中execute()和submit()两个方法的区别(源码&实战全解析)

// AbstractExecutorService.java
public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    // 关键点1：将 Runnable 包装为 RunnableFuture
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);  // 关键点2：最终还是调用 execute()
    return ftask;    // 关键点3：返回 Future 对象
}

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

// 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);
}

ExecutorService executor = Executors.newFixedThreadPool(2);

executor.execute(() -> {
    throw new RuntimeException("任务异常");
});

// 主线程无法捕获这个异常！
// 异常会直接抛出到线程池的 UncaughtExceptionHandler

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());
}

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;
}

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("任务超时，已取消");
}

// 设置全局异常处理器
Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
    System.out.println("线程 " + t.getName() + " 发生异常: " + e);
});

ExecutorService executor = Executors.newFixedThreadPool(2);

executor.execute(() -> {
    throw new RuntimeException("异常会被 UncaughtExceptionHandler 捕获");
});

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());
            }
        }
    }
};