谈谈Runnable、Future、Callable、FutureTask之间的关系

我不是女神ヾ 2022-12-04 03:26 128阅读 0赞

注：该篇文章，只是用来梳理他们之间的关系，分析FutureTask的源码则会另开篇幅。

--------------------

## 创建线程的两种方式 ##

一种是实现Runnable接口，实现其run方式；另外一种是继承Thread类，重写其run方法。

这一点可以从Thread类中的注释看到：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTkxOTAz_size_16_color_FFFFFF_t_70][]

--------------------

## Runnable ##

Thread类也实现了Runnable接口，Runnable接口的源码如下：

@FunctionalInterface
    public interface Runnable {
        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see     java.lang.Thread#run()
         */
        public abstract void run();
    }

因此，可以看得出，不管我们是实现Runnable接口，还是继承Thread类，run方式的返回类型都是void，我们都无法拿到线程运行的返回结果。

如果非要拿到线程运行的结果怎么办？Callable便应运而生了。

--------------------

## Callable ##

@FunctionalInterface
    public interface Callable<V> {
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        V call() throws Exception;
    }

Callable还是一个函数式接口，其泛型参数类型与返回值类型一致。

为了更清晰的说明他们之间的关系，这里先放上类图结构

--------------------

## 类图关系 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTkxOTAz_size_16_color_FFFFFF_t_70 1][]

--------------------

## Future ##

Callable接口，只是用于单纯地去获得返回值，但是什么时候去获取，或者查看线程运行的状态，就需要借助Future

Future的源码如下：

public interface Future<V> {
    
        //取消任务的执行，任务已经完成或者已经被取消时，调用此方法，会返回false
        boolean cancel(boolean mayInterruptIfRunning);
    
        //判断任务是否被取消
        boolean isCancelled();
    
        //判断任务是否完成(正常完成、异常以及被取消，都将返回true)
        boolean isDone();
    
        //阻塞地获取任务执行的结果
        V get() throws InterruptedException, ExecutionException;
    
        //在一定时间内，阻塞地获取任务执行的结果
        V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    
    }

可以看得出来，Future提供了取消任务、获取任务执行的状态与获取结果的能力。

--------------------

## RunnableFuture ##

public interface RunnableFuture<V> extends Runnable, Future<V> {
        /**
         * Sets this Future to the result of its computation
         * unless it has been cancelled.
         */
        void run();
    }

RunnableFuture继承了Runnable与Future接口，没什么好说的。

以上说的，Runnable、Callable、Future以及RunnableFuture都是接口，真正干活还得靠FutureTask

--------------------

## FutureTask ##

FutureTask实现了RunnableFuture接口，而RunnableFuture继承了Runnable与Future接口，因此FutureTask既可以作为一个Runnable被Thread执行，也可以获取到Future异步计算的结果。

从上面的类图可以看到，传入一个Callable类型的参数可以构造FutureTask对象。

下面这个例子，使用构造出来的FutureTask对象，传入Thread的构造函数中，调用start方法以启动线程。

package com.qcy.testFutureTask;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /**
     * @author qcy
     * @create 2020/09/07 09:27:06
     */
    public class Main {
    
        static class Task implements Callable<Integer> {
            @Override
            public Integer call() throws Exception {
                //模拟任务耗时
                Thread.sleep(2000);
                return 1;
            }
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //FutureTask接收一个Callable实现类
            FutureTask<Integer> futureTask = new FutureTask<>(new Task());
    
            //FutureTask实现了RunnableFuture,间接实现了Runnable接口,因此可作为参数传给Thread的构造方法中
            new Thread(futureTask).start();
    
            //get()方法会阻塞2秒,输出1
            int result = futureTask.get();
            System.out.println(result);
        }
    }

当然也可以将构造出来FutureTask对象，提交进线程池中。对线程池不了解的同学，可以移步这一篇文章[说说线程池][Link 1]

package com.qcy.testFutureTask;
    
    import java.util.concurrent.*;
    
    /**
     * @author qcy
     * @create 2020/09/07 09:27:06
     */
    public class Main {
    
        static class Task implements Callable<Integer> {
            @Override
            public Integer call() throws Exception {
                //模拟任务耗时
                Thread.sleep(2000);
                return 1;
            }
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            ExecutorService pool = Executors.newFixedThreadPool(1);
    
            //FutureTask接收一个Callable实现类
            FutureTask<Integer> futureTask = new FutureTask<>(new Task());
    
            //这里使用一个Runnable的实现类，因此可以使用FutureTask
            pool.submit(futureTask);
    
            //get()方法会阻塞2秒,输出1
            int result = futureTask.get();
            System.out.println(result);
    
            pool.shutdown();
        }
    }

当然，ExecutorService内的submit方法，可以直接传入Callable的实现类。

package com.qcy.testFutureTask;
    
    import java.util.concurrent.*;
    
    /**
     * @author qcy
     * @create 2020/09/07 09:27:06
     */
    public class Main {
    
        static class Task implements Callable<Integer> {
            @Override
            public Integer call() throws Exception {
                //模拟任务耗时
                Thread.sleep(2000);
                return 1;
            }
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            ExecutorService pool = Executors.newFixedThreadPool(1);
    
            //这里使用一个Callable的实现类，因此可以使用FutureTask
            Future<Integer> future = pool.submit(new Task());
    
            //get()方法会阻塞2秒,输出1
            int result = future.get();
            System.out.println(result);
    
            pool.shutdown();
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTkxOTAz_size_16_color_FFFFFF_t_70]: /images/20221123/1bd6d0d76d144d299aed4dc8493edb31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTkxOTAz_size_16_color_FFFFFF_t_70 1]: /images/20221123/ad5d935786db4317b4cff76097f5537e.png
[Link 1]: https://blog.csdn.net/qq_33591903/article/details/106239102