7.JUC组件拓展-Callable、Future和FutureTask

2024年1月7日 281次阅读 来源: JUC

Callable、Future和FutureTask

创建线程有2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。
这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。

而自从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。

callable和runnable

Runnable是一个接口，在它里面只声明了一个run()方法：

public interface Runnable {
    public abstract void run();
}

由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。

Callable位于java.util.concurrent包下，它也是一个接口，在它里面也只声明了一个方法，只不过这个方法叫做call()：

//call()函数返回的类型就是传递进来的V类型
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呢？一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法的重载版本：

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

注意，这里线程的submit()和execute()的区别：

例如，创建可缓存线程池，Executors.newCachedThreadPool()，源码如下：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

该方法返回的是一个ExecutorService接口，而这个接口继承Executor接口，Executor是最上层的，其中只包含一个execute()方法：

public interface Executor {
    void execute(Runnable command);
}

execute()方法的入参为一个Runnable，返回值为void。

而submit已经在上面说了，是ExecutorService接口中的方法，是由返回值的。

所以他们的区别是：

  • 接收的参数不一样;
  • submit()有返回值，而execute()没有;

– submit()可以进行Exception处理;

两者功能大致相似，callable更强大一些，因为对线程执行后可以有返回值，并且可以抛出异常。

关于runnable创建线程就不再赘述了，callable与future结合起来一起使用，在下面将给出例子。

Future接口

对于callable或者runnable的任务，可以进行取消，查询任务是否被取消，查询任务是否完成以及获取结果。future可以得到别的线程任务方法的返回值。

必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

Future类位于java.util.concurrent包下，它是一个接口：

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;
}

在Future接口中声明了5个方法，下面依次解释每个方法的作用：

cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。
– 1.如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；
– 如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，- 若mayInterruptIfRunning设置为false，则返回false；
-如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。

isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。

isDone方法表示任务是否已经完成，若任务完成，则返回true；

get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；

get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

也就是说Future提供了三种功能：判断任务是否完成；能够中断任务；能够获取任务执行结果。

因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。

@Slf4j
public class FutureTest {
    static class MyCallable implements Callable<String>{
        @Override
        public String call() throws Exception {
            log.info("do something in callable...");
            Thread.sleep(5000);
            return "Done";
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService exec = Executors.newCachedThreadPool();
        //获取callable运行结果
        Future<String> future = exec.submit(new MyCallable());
        log.info("do something in main...");
        Thread.sleep(1000);
        String result = future.get();
        log.info("result={}...",result);
        exec.shutdown();
    }
}

运行结果：

21:21:20.441 [main] INFO - do something in main...
21:21:20.462 [pool-1-thread-1] INFO - do something in callable... //等5秒后才拿到结果
21:21:25.462 [main] INFO - result=Done...

FutureTask类

我们先来看一下FutureTask的实现：

public class FutureTask<V> implements RunnableFuture<V>

FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：

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

可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

事实上，FutureTask是Future接口的一个唯一实现类。

FutureTask提供了2个构造器：

public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}

那么，我们就可以在FutureTask传入一个callable任务了：

@Slf4j
public class FutureTaskTest {
    public static void main(String[] args) throws Exception {
        FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
            @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);
    }
}

运行效果同上。都可以实现一个场景：一个复杂的任务执行，但是不是立即需要他的结果，而是我这个线程继续干其他事情，等需要他 结果的时候，再去跟她要。我可以拿到他的返回值继续做其他事情。

    原文作者：JUC
    原文地址: https://blog.csdn.net/sunweiguo1/article/details/80384144
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞