[Java并发与多线程]（二十一）获取子线程的执行结果(*)【来而不往非礼也】

最新推荐文章于 2023-07-20 14:08:49 发布

徐俊生

最新推荐文章于 2023-07-20 14:08:49 发布

阅读量601

点赞数 1

分类专栏：多线程

本文链接：https://blog.csdn.net/D812359/article/details/112408788

版权

多线程专栏收录该内容

29 篇文章 3 订阅

订阅专栏

Future和Callable——治理线程的第二大法宝

1、Runnable的缺陷
2、Callable接口
3、Future类

1、Runnable的缺陷

不能返回一个返回值；也不能抛出checked Exception。

public class RunnableCantThrowsException {

    public void add() throws Exception {

    }

    public static void main(String[] args) {
        Runnable runnable = () -> {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        };
    }
}

为什么会有这样的缺陷？
因为run方法在定义的时候有两点：第一点返回的是void；第二点没有声明异常；这两点在我们实现的时候是没有办法改变的。

Runnable为什么设计成这样？
如果说run可以抛出异常，那么最终是Thread类接收；但是最终处理异常我们也处理不了，所以不如在run方法中try catch起来，然后做一些处理措施。

针对于无法抛出检查后异常这个缺陷的补救措施
引出Callable接口。

2、Callable接口

类似于Runnable，被其他线程执行的任务；实现call方法；有返回值。

3、Future类

作用：一个方法的计算可能会很耗时，但是在计算的过程中我没有必要在原地等你返回，我可以用子线程去执行，等到计算出结果之后我在用Future直接获取过来。
Callable和Future的关系

我们可以用Future.get来获取Callable接口返回的执行结果；还可以通过来判断任务是否Future.isDone()已经执行完了；以及取消这个任务；限时获取任务的结果等。
在call()未执行完毕之前，调用get()的线程(假定此时是主线程)会被阻塞，直到call()方法返回了结果后，此时future.get()才会得到该结果，然后主线程才会切换到runnable状态；

总结：Future是一个存储器，它存储了call()这个任务的结果，而这个任务的执行时间是无法提前确定的，因为这完全取决于方法call()执行的情况。
Callable和Future是一个相互配合的关系，最终通过Future拿到call方法执行的结果。

3.1、Future的主要方法：5个

1、get()方法：获取结果

get方法的行为取决于Callable任务的状态，只有以下这5种情况：
a、任务正常完成：get方法会立刻返回结果；
b、任务尚未完成(任务还没开始或进行中)：get将阻塞并直到任务完成；
c、任务执行过程中抛出Exception：get方法会抛出ExecutionException，这里的抛出异常，是call()执行时产生的那个异常，看到这个异常类型是java.util.concurrent.ExecutionException。不论call()执行时抛出的异常类型是什么，最后get()方法抛出的异常类型都是ExecutionException。
d、任务被取消：get方法会抛出CancellationException
e、任务超时：get方法有一个重载方法，是传入一个延迟时间的，如果时间到了还没有获得结果，get方法就会抛出TimeoutException。

2、get(long timeout, TimeUnit unit)：有超时的获取
a、超时的需求很常见
b、用get(long timeout, TimeUnit unit)方法时，如果call()在规定时间内完成了任务，那么就会正常获取到返回值；而如果在指定时间内没有计算出结果，那么就会抛出TimeoutException。
c、超时不获取，任务需取消；

3、cancel方法：取消任务的执行
a、如果这个任务还没有开始执行，那么这种情况最简单，任务会被正常的取消，未来也不会被执行，方法返回true。
b、如果任务已完成，或者已取消：那么cancel()方法会执行失败，方法返回false；
c、如果这个任务已经开始执行了，那么这个取消方法将不会直接取消该任务，而是会根据我们填的参数mayInterruptIfRunning做判断：true——发送中断信号；false——不发送，程序继续执行。

Future.cancel(true)适用于：我们知道中断的任务有能力正确处理中断的时候；
Future.cancel(false)仅用于避免启动尚未启动的任务，适用于：
- 未能处理interrupt的任务
- 不清楚任务是否支持取消
- 需要等待已经开始的任务执行完成

4、isDone()方法：判断线程是否执行完毕
5、isCancelled()方法：判断是否被取消

3.2、Future用法

3.2.1 用法1：线程池的submit方法返回Future对象

首先，我们要给线程池提交我们的任务，提交时线程池会立刻返回给我们一个空的Future容器。当线程的任务一旦执行完毕，也就是当我们可以获取结果的时候，线程池便会把该结果填入到之前给我们的那个Future中去(而不是创建一个新的Future)，我们此时便可以从该Future中获取任务执行的结果。

3.2.1.1 get的基本用法

public class OneFuture {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        Future<Integer> future = service.submit(new CallableTask());
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }

    static class CallableTask implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return new Random().nextInt();
        }
    }
}

3.2.1.2 Callable的Lambda表达式形式

public class OneFutureLambda {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = () ->{
            Thread.sleep(3000);
            return new Random().nextInt();
        };

        Future<Integer> future = service.submit(callable);
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }

}

3.2.1.3 多个任务，用Future数组来获取结果

演示批量提交任务时，用List来批量接收结果

public class MultiFutures {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(20);

        ArrayList<Future> futures = new ArrayList<>();

        for (int i = 0; i < 20; i++) {
            Future<Integer> future = service.submit(new CallableTask());
            futures.add(future);
        }

        Thread.sleep(5000);
        for (int i = 0; i < 20; i++) {
            Future<Integer> future = futures.get(i);
            try {
                Integer integer = future.get();
                System.out.println(integer);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }

        }
    }

    static class CallableTask implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return new Random().nextInt();
        }
    }
}

3.2.1.4 任务执行过程中抛出Exception和isDone展示

演示get方法过程中抛出异常，for循环为了演示抛出Exception的时机：并不是说一产生异常就抛出，直到我们get执行时，才会抛出。

public class GetException {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(20);
        Future<Integer> future = service.submit(new CallableTask());
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println(i);
                Thread.sleep(500);
            }
            System.out.println(future.isDone());
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("InterruptedException异常");
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.out.println("ExecutionException异常");
        }
    }

    static class CallableTask implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            throw new IllegalArgumentException("Callable抛出异常");
        }
    }
}

3.2.1.5 获取任务超时

演示get的超时方法，需要注意超时后处理，调用future.cancel()。
演示cancel传入true和false的区别，代表是否中断正在执行的任务。

public class Timeout {

    private static final Ad DEFAULT_AD = new Ad("无网络时候的默认广告");

    private static final ExecutorService exec = Executors.newFixedThreadPool(10);

    static class Ad {
        String name;

        public Ad(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Ad{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

    static class FetchAdTask implements Callable<Ad> {


        @Override
        public Ad call() throws Exception {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                System.out.println("sleep期间被中断了");
                return new Ad("被中断时候的默认广告");
            }
            return new Ad("旅游订票哪家强？找某程");
        }
    }

    public void printAd() {
        Future<Ad> f = exec.submit(new FetchAdTask());
        Ad ad;
        try {
            ad = f.get(2000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            ad = new Ad("被中断时候的默认广告");
        } catch (ExecutionException e) {
            ad = new Ad("异常时候的默认广告");
        } catch (TimeoutException e) {
            ad = new Ad("超时时候的默认广告");
            System.out.println("超时，未获取到广告");
            //传入false不会中断，继续运行
            boolean cancel = f.cancel(true);//任务正在执行，是否需要interrupt打断
            System.out.println("cancel的结果：" + cancel);
        }
        exec.shutdown();
        System.out.println(ad);
    }

    public static void main(String[] args) {
        Timeout timeout = new Timeout();
        timeout.printAd();
    }

}

3.2.2 用法2：用FutureTask来创建Future

1、用FutureTask来获取Future和任务的结果
2、FutureTask是一种包装器，可以把Callable转化成Future和Runnable，它同时实现二者的接口。
在这里插入图片描述
3、把Callable实例作为参数，生成FutureTask的对象，然后把这个对象当做一个Runnable对象，用线程池或另起线程去执行这个Runnable对象，最后通过FutureTask获取刚才执行的结果。

public class FutureTaskDemo {
    public static void main(String[] args) {
        //第一步:建立一个任务
        Task task = new Task();

        //第二步：创建FutureTask，在构造函数中传入 task
        FutureTask<Integer> integerFutureTask = new FutureTask<>(task);

        //第三步：放到线程中去执行
        //new Thread(integerFutureTask).start();

        ExecutorService service = Executors.newCachedThreadPool();
        service.submit(integerFutureTask);

        try {
            System.out.println("task运行结果：" + integerFutureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class Task implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程正在计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}