Java 中使用 Callable 创建线程的方法

一、Callable 接口概述​

Callable接口位于java.util.concurrent包中，与Runnable接口类似，同样用于定义线程执行的任务，但它具有以下独特特性：​

1. 支持返回值：Callable接口声明了一个call()方法，该方法会在任务执行完毕后返回结果，这使得我们可以在主线程中获取子线程的执行结果，方便进行后续处理。​

1. 可抛出异常：call()方法允许抛出任何类型的异常，包括受检异常，相比Runnable接口中run()方法只能通过try-catch捕获非受检异常，Callable在异常处理上更加灵活。​

Callable接口是一个泛型函数式接口，其定义如下：

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

二、使用 Callable 创建线程的方法​

1. 通过 FutureTask 结合 Thread​

FutureTask类实现了RunnableFuture接口，而RunnableFuture继承了Runnable和Future接口，这使得FutureTask既可以作为Runnable被线程执行，又可以作为Future获取Callable任务的执行结果。具体使用步骤如下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

// 定义Callable实现类
class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

public class CallableThreadExample {
    public static void main(String[] args) {
        // 创建Callable实例
        Callable<Integer> callable = new MyCallable();
        // 创建FutureTask实例，并将Callable实例作为参数传入
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        // 创建Thread实例，并将FutureTask作为参数传入
        Thread thread = new Thread(futureTask);
        // 启动线程
        thread.start();

        try {
            // 获取Callable任务的执行结果
            Integer result = futureTask.get();
            System.out.println("计算结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，首先定义了一个实现Callable接口的MyCallable类，在call()方法中实现具体的计算逻辑，这里是计算 1 到 100 的整数和。然后在main方法中，创建Callable实例和对应的FutureTask实例，将FutureTask实例作为参数传递给Thread构造函数创建线程并启动。最后通过futureTask.get()方法获取Callable任务的执行结果，如果在获取结果过程中线程被中断或任务执行过程中抛出异常，会分别捕获InterruptedException和ExecutionException进行处理。

2. 通过 ExecutorService 线程池

import java.util.concurrent.*;

class MyCallable2 implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(2000);
        return "任务执行完成";
    }
}

public class CallableThreadPoolExample {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        // 创建Callable实例
        Callable<String> callable = new MyCallable2();
        // 提交Callable任务，并返回Future对象
        Future<String> future = executorService.submit(callable);

        try {
            // 获取任务执行结果
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            executorService.shutdown();
        }
    }
}

在这段代码中，首先通过Executors.newFixedThreadPool(3)创建了一个固定大小为 3 的线程池executorService。接着定义了一个MyCallable2类实现Callable接口，在call()方法中让线程休眠 2 秒后返回结果。然后使用executorService.submit(callable)方法提交Callable任务，该方法会立即返回一个Future对象，通过future.get()方法获取任务的执行结果。最后在finally块中调用executorService.shutdown()方法关闭线程池，以释放资源。

三、Callable 与 Runnable 的对比​

特性​	Callable​	Runnable​
返回值​	支持返回值，通过call()方法返回任务执行结果，结果类型由泛型指定​	不支持返回值，run()方法返回值为void​
异常处理​	可以抛出任何类型的异常，包括受检异常，需要在调用端显式处理​	只能捕获非受检异常，受检异常需要在run()方法内部通过try-catch处理​
实现方式​	是一个泛型接口，需实现call()方法​	是一个普通接口，需实现run()方法​
配合使用对象​	通常与FutureTask或ExecutorService结合使用，用于获取任务执行结果​	可直接与Thread类配合使用，或提交到线程池执行​

​

四、总结

Callable接口为 Java 多线程编程带来了更丰富的功能和更高的灵活性，通过与FutureTask或ExecutorService线程池结合使用，我们可以方便地获取线程执行结果并进行异常处理。在实际开发中，当我们需要在多线程任务执行完毕后获取结果，或者需要更精细地处理任务执行过程中的异常时，Callable接口是一个非常好的选择。同时，合理利用线程池来管理Callable任务，能够提高程序的性能和资源利用率，让多线程程序更加高效、稳定地运行。