Java ExecutorService的任务提交方式有哪些

Java ExecutorService的主要任务提交方式

1. execute(Runnable command)

execute是ExecutorService最基础的异步执行方法，接收一个Runnable接口实现（无返回值），将任务提交给线程池异步执行。其特点是无法获取任务执行结果或异常——若任务抛出未捕获异常，异常会直接传递给线程池的未捕获异常处理器（默认打印堆栈），调用者无法感知。适用于不需要关心任务结果的场景（如日志记录、消息发送等）。
示例：

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(() -> System.out.println("Task executed asynchronously"));
executor.shutdown();

2. submit(Runnable task)

submit是ExecutorService对Runnable任务的增强提交方法，同样接收Runnable接口实现，但会返回一个Future<?>对象。通过Future可以检查任务是否完成（isDone()）、取消任务（cancel()），但无法获取任务执行结果（get()返回null）。适用于需要监控任务状态但不关心结果的场景。
示例：

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<?> future = executor.submit(() -> {
    System.out.println("Runnable task with Future");
});
System.out.println("Task done? " + future.isDone()); // false（任务未完成）
executor.shutdown();

3. submit(Callable task)

submit的重载方法，接收Callable<T>接口实现（有返回值），返回一个Future<T>对象。Callable的call()方法可以返回任意类型的值（通过泛型T指定），通过Future.get()可以阻塞获取任务执行结果（若任务未完成，当前线程会等待）；若任务抛出异常，异常会被封装在ExecutionException中，通过future.get().getCause()获取。适用于需要获取任务结果的场景（如计算、数据查询等）。
示例：

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<Integer> future = executor.submit(() -> {
    System.out.println("Callable task executing");
    return 42; // 返回计算结果
});
try {
    Integer result = future.get(); // 阻塞获取结果
    System.out.println("Task result: " + result); // 输出：42
} catch (ExecutionException e) {
    e.printStackTrace();
}
executor.shutdown();

4. submit(Runnable task, T result)

submit的第三种重载形式，接收一个Runnable和一个result参数，返回Future<T>。其作用是为Runnable任务关联一个结果模板——Future.get()会返回传入的result（而非任务执行结果），主要用于需要统一处理任务状态的场景（如标记任务已完成，但无需实际返回值）。
示例：

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<String> future = executor.submit(() -> {
    System.out.println("Runnable task with custom result");
}, "Task Completed");
try {
    String result = future.get(); // 返回传入的"Task Completed"
    System.out.println("Custom result: " + result);
} catch (ExecutionException e) {
    e.printStackTrace();
}
executor.shutdown();

5. invokeAll(Collection<? extends Callable> tasks)

invokeAll用于批量提交多个Callable任务，接收一个Callable集合，返回一个List<Future<T>>（每个Future对应一个任务的结果）。该方法会阻塞当前线程，直到所有任务完成（无论成功或失败）；若任务执行过程中抛出异常，异常会被封装在对应的Future中。适用于需要批量执行多个任务并等待所有任务完成的场景（如并行处理多个独立任务）。
示例：

ExecutorService executor = Executors.newFixedThreadPool(3);
List<Callable<String>> tasks = new ArrayList<>();
tasks.add(() -> "Task 1 result");
tasks.add(() -> "Task 2 result");
tasks.add(() -> "Task 3 result");
List<Future<String>> futures = executor.invokeAll(tasks);
for (Future<String> future : futures) {
    try {
        System.out.println(future.get()); // 依次输出每个任务的结果
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}
executor.shutdown();

6. invokeAny(Collection<? extends Callable> tasks)

invokeAny同样用于批量提交Callable任务，但返回第一个成功完成的任务结果（即没有抛出异常的任务）。若所有任务都抛出异常，则抛出ExecutionException；若任务未完成（如超时，需配合ExecutorService的超时机制），则抛出TimeoutException。该方法会自动取消其他未完成的任务，适用于只需要一个任务结果的场景（如多策略并行尝试，取最快成功的策略）。
示例：

ExecutorService executor = Executors.newFixedThreadPool(3);
List<Callable<String>> tasks = new ArrayList<>();
tasks.add(() -> { Thread.sleep(1000); return "Task 1"; });
tasks.add(() -> { Thread.sleep(500); return "Task 2"; }); // 最快完成
tasks.add(() -> { Thread.sleep(1500); return "Task 3"; });
try {
    String result = executor.invokeAny(tasks); // 返回"Task 2"
    System.out.println("First completed task: " + result);
} catch (ExecutionException | InterruptedException e) {
    e.printStackTrace();
}
executor.shutdown();