Java并发教程之Callable和Future接口详解

在Java多线程编程中，Callable和Future是两个非常重要的接口。它们可以让我们方便地创建并发任务，并且可以在任务执行完毕后获取到任务的结果。本教程将详细讲解Callable和Future接口的使用方法和注意事项。

Callable接口

Callable接口是一个泛型接口，它定义了一个call()方法，该方法可以返回一个值，并且可以抛出异常。具体定义如下：

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

Callable接口可以用于创建并发任务，其使用方法如下：

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 省略具体实现
        return 123;
    }
}

MyCallable task = new MyCallable();
Future<Integer> future = executorService.submit(task);

在上面的示例中，我们定义了一个MyCallable类，实现了Callable接口的call()方法。在主线程中，我们创建了一个Future对象，该对象表示异步执行的结果。我们将MyCallable对象作为参数传递给了线程池的submit()方法，线程池会异步执行MyCallable任务，并将执行结果封装成一个Future对象返回给主线程。

Future接口

Future接口表示异步执行的结果。它提供了一些方法，可以用于查看异步执行的结果是否完成，获取异步执行的结果，或者取消异步执行的任务。具体定义如下：

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

其中，比较常用的是get()方法，该方法可以用于获取异步执行的结果。如果任务尚未完成，则该方法会阻塞直到任务完成并返回结果。如果任务执行过程中出现异常，则在调用get()方法时会将异常信息抛出。

下面是一个使用Future的示例：

Future<Integer> future = executorService.submit(new MyCallable());
// do something...
Integer result = future.get();
System.out.println(result);

在上面的示例中，我们创建了一个Future对象，用于获取MyCallable任务的执行结果。在主线程中，我们可以做一些其他的事情，最后通过调用Future的get()方法获取到任务执行的结果并打印出来。

注意事项

在使用Callable和Future接口时，需要注意以下几点：

1. Callable任务返回的结果类型必须和Future对象声明的类型一致。否则在调用get()方法时会抛出ClassCastException异常。

2. 在调用Future的get()方法时，如果任务尚未执行完毕，则会阻塞当前线程，直到任务执行完毕。因此，需要特别注意在主线程中不要调用get()方法阻塞主线程。

3. 在调用Future的get()方法时，如果任务执行过程中出现异常，则在调用get()方法时会将异常信息抛出。因此，在使用get()方法时需要特别注意在try-catch语句块中处理异常。

示例

下面是使用Callable和Future接口实现简单的多线程异步计算的示例：

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(4);

        Future<Integer> future1 = executorService.submit(new MyCallable(1, 1000));
        Future<Integer> future2 = executorService.submit(new MyCallable(2, 2000));
        Future<Integer> future3 = executorService.submit(new MyCallable(3, 3000));

        System.out.println("计算中...");

        int sum = future1.get() + future2.get() + future3.get();

        System.out.println("计算结果：" + sum);

        executorService.shutdown();
    }

    static class MyCallable implements Callable<Integer> {
        private int id;
        private int sleep;

        MyCallable(int id, int sleep) {
            this.id = id;
            this.sleep = sleep;
        }

        @Override
        public Integer call() throws Exception {
            try {
                Thread.sleep(sleep);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("线程" + id + "计算完毕");

            return id;
        }
    }
}

在上面的示例中，我们创建了一个线程池，并向其中提交了三个MyCallable任务。每个任务会计算一个数字，并在计算完成后返回数字的值。主线程等待三个任务全部完成，并将计算结果相加后打印出来。

输出结果如下：

计算中...
线程1计算完毕
线程2计算完毕
线程3计算完毕
计算结果：6

总结

Callable和Future接口是Java多线程编程中非常重要的接口，可以用于创建并发任务，并且可以在任务执行完毕后获取到任务的结果。在使用Callable和Future接口时，需要注意返回结果的类型和调用get()方法时可能会出现的阻塞和异常情况。