ThreadPool 之 Callable、Future 和 FutureTask

最新推荐文章于 2023-12-02 23:54:59 发布

RojerAlone

最新推荐文章于 2023-12-02 23:54:59 发布

阅读量681

点赞数

分类专栏： Java JDK源码学习文章标签：线程 jdk 源码 threadpool 线程池

本文链接：https://blog.csdn.net/Alone_Rojer/article/details/76650430

版权

Java 同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

JDK源码学习

11 篇文章 0 订阅

订阅专栏

本文介绍了Java中的Callable接口和Future接口，以及如何使用FutureTask来获取线程执行的结果。通过示例代码展示了CallableTask的实现及如何利用ExecutorService提交任务并获取结果。

摘要由CSDN通过智能技术生成

接上篇文章 ThreadPool 之线程池实现类 ThreadPoolExecutor。

`Callable`、`Future` 和 `FutureTask`

　　一般情况下，线程有两种创建方式，一种是继承 Thread 类，一种是实现 Runnable 接口。在线程运行执行的都是 run 方法，这是一个 void 方法，没有返回值。如果要获取线程执行的结果，就必须传入一个变量，在执行完之前将结果写入这个变量中。

　　从 JDK1.5 开始，Java 提供了 Callable 和 Future 接口，通过它们可以返回执行结果。

`Callable`

　　Callable 是一个接口，其中只有一个 call 方法：

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

　　可以看到这是一个泛型接口，返回一个结果值。

`Future`

　　Future 是一个接口，代码如下：

public interface Future<V> {

    /**
     * mayInterruptIfRunning 表示如果任务正在执行是否允许中断任务
     */
    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    /**
     * 阻塞地获取执行结果，如果还没有执行完毕会一直等待直到执行完毕
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * 如果在执行时间内还没有执行完，返回 null
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

　　因为 Future 是一个接口，FutureTask 是它的实现类。

`FutureTask`

public class FutureTask<V> implements RunnableFuture<V> {
    public FutureTask(Runnable runnable, V result) {
        // 调用 Executors 的方法将 runnable 封装为 callable
        this.callable = Executors.callable(runnable, result); 
        this.state = NEW;       // ensure visibility of callable
    }
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    // 省略其他代码
}

　　FutureTask 实现了 RunnableFuture<V> 接口，查看RunnableFuture<V>：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

　　RunnableFuture<V> 接口又继承了 Runnable 接口和 Future 接口，所以 FutureTask 既能被当做线程执行又能当做 Future 获取执行结果。

Demo

/**
 * Created by RojerAlone on 2017-08-03.
 */
public class FutureTaskDemo {

    static class CallableTask implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            int res = 0;
            System.out.println("正在执行任务......");
            Thread.sleep(1000 * 3);
            for (int i = 0; i < 100; i++) {
                res += i;
            }
            return res;
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        CallableTask task = new CallableTask();
        try {
            Future future = executorService.submit(task);
            while (!future.isDone()) {
                System.out.println("callable task is running......");
                Thread.sleep(1000);
            }
            System.out.println("callable task 运行结果为：" + future.get());
            FutureTask futureTask = new FutureTask(task);
            new Thread(futureTask).start();
            while (!futureTask.isDone()) {
                System.out.println("future task is running......");
                Thread.sleep(1000);
            }
            System.out.println("future task 运行结果为：" + futureTask.get());
            executorService.shutdownNow();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

运行结果：

callable task is running......
正在执行任务......
callable task is running......
callable task is running......
callable task is running......
callable task 运行结果为：4950
future task is running......
正在执行任务......
future task is running......
future task is running......
future task 运行结果为：4950