J.U.C 组件之 FutureTask

Futrue Task 是 J.U.C 的组件 , 但不是 AQS 的子类

Futrue Task

我们知道在 Java 中 , 创建一个线程有两种方法 , 一种是直接继承Thread , 另外一种是实现 Runable接口 , 但是这两种方式都有一个共同的缺陷是 , 它们在执行为任务时, 都无法获取到任务的结果 . 在 jdk 1.5 之后 , 提供了Callable 和 Future , 通过它俩可以在任务执行修改完毕之后得到任务的执行结果 .

Callable 和 Runable 接口对比

Runable 比较简单, 它是一个接口, 而且只有一个方法 run() , Callable 也较为简单, 不同的是它是一个泛型的接口 , 它有一个 call()函数 , 这个函数的返回类型就是我们创建 Callable传进去的类型, 两者比较相比, Callable 功能较强大一些, 主要是其被线程执行后有返回值, 并且能抛出异常 .

Future接口

对于 Callable 或者 Future 的任务 , Futrue 可以对其取消 , 查询其任务是否被取消, 查询任务是否完成, 已经获取结果等 . 通常线程都是属于异步计算模型的, 你不可嫩从别的线程得到方法的返回值 , 这个时候 Futrue 就派上用场了 , Futrue 可以监视目标线程调用 call() 的情况, 当你调用 Futrue get() 方法的时候 , 就可以获得它的结果 , 这个时候通常线程不会直接完成, 当前线程就开始阻塞 , 直到 call()方法返回结果, 线程才继续执行 . 总之就是, Futrue 可以得到别的线程任务方法的返回值 .

Futrue Task 类

其父类是 RunableFutrue , 而 Runable Futrue 继承了 Runable 和 Futrue 这两个接口 . 所以 Futrue Task 最后执行的也是 Callable 类型的任务 .

/**
 * A {@link Future} that is {@link Runnable}. Successful execution of
 * the {@code run} method causes completion of the {@code Future}
 * and allows access to its results.
 * @see FutureTask
 * @see Executor
 * @since 1.6
 * @author Doug Lea
 * @param  The result type returned by this Future's {@code get} method
 */
public interface RunnableFuture extends Runnable, Future {
    // 继承了 Runnable 和 Future
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

如果构造函数数 Runable 的话 ,它或转换成 Callable 类型. Futrue Task 实现了两个接口 Runable 和 Futrue , 所以它既可以作为Runable被线程执行 , 又可以作为 Futrue 得到 Callable 的返回值 . 这两个接口的组合有什么优点呢 , 比如说 , 有一个很费时逻辑需要计算, 并返回结果, 同时这个值又不是马上需要, 就可以使用它, 用另外一个线程去就按返回值, 而当前现在在使用这个返回值之前可以做其他的操作,等到需要这个返回值的时候, 再通过 Future得到 .

代码实例

Future 代码示例

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

@Slf4j
public class FutureExample {

    // 定义一个Callable的任务 MyCallable , 这里返回一个String 类型
    static class MyCallable implements Callable {

        @Override
        public String call() throws Exception {
            // 假如 在这个callable 做一些事情需要比较长时间 , 咱们让线程 sleep 5s
            log.info("do something in callable");
            Thread.sleep(5000);
            // 任务完成了 返回 Done
            return "Done";
        }
    }

    public static void main(String[] args) throws Exception {

        // 使用Future和 Callable 的时候一般是通过线程池类调用的 . 在这里 申明一个线程池

        ExecutorService executorService = Executors.newCachedThreadPool();

        // 让线程池直接提交该任务 , 返回任务结果
        // 这样就相当于用 Future 接收了另外一个线程任务计算的结果
        Future future = executorService.submit(new MyCallable());
        log.info("do something in main");
        Thread.sleep(1000);
        // 获取之前的任务返回了什么结果
        String result = future.get();
        log.info("result：{}", result);
    }
}

Future Task 示例

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class FutureTaskExample {

    public static void main(String[] args) throws Exception {
        FutureTask futureTask = new FutureTask(new Callable() {
            @Override
            public String call() throws Exception {
                log.info("do something in callable");
                Thread.sleep(5000);
                return "Done";
            }
        });

        new Thread(futureTask).start();
        log.info("do something in main");
        Thread.sleep(1000);
        String result = futureTask.get();
        log.info("result：{}", result);
    }
}

上两示例代码结果输出如下图

输出

总结

FutureTask 是将 Future 和 Callable 相关的东西都结合在一起了, 所以在他们三个之间 , 使用 FutureTask 就可以解决你想做的事情 . 如果在Java 程序中, 如果你想起一个线程去做一些事情的时候, 并且你还希望获得线程的结果已经它是否正常执行, 就可以使用 FutureTask .