获取子线程执行结果

Callable

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

Future

• Callable和Future的关系我们可以用Future.get来获取Callable接口返回的执行结果还可以通过Future.isDone()来判断任务是否已经执行完了,以及取消这个任务,限时获取任务的结果等。
• 在call()未执行完毕之前,调用get()的线程(假定此时是主线程)会被阻塞,直到call()方法返回了结果后,此时future.get()才会得到该结果,然后主线程才会切换到runnable状态
• 所以Future是一个存储器,它存储了call(这个任务的结果而这个任务的执行时间是无法提前确定的,因为这完全取决于call()方法执行的情况

get()

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

get(long timeout, TimeUnit unit) :

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

cancel

• 取消任务
• 如果这个任务还没有开始执行,那么这种情况最简单,任务会被正常的取消,未来也不会被执行,方法返回true。
• 如果任务已完成,或者已取消:那么cancel)方法会执行失败,方法返回false。
• 如果这个任务已经开始执行了,那么这个取消方法将不会直接取消该任务,而是会根据我们填的参数mayInterruptifRunning做判断。
• Future.cancel(true)适用于:
  1. 任务能够处理interrupt。
• Future.cancel(false)仅用于避免启动尚未启动的任务,适用于:
  1. 未能处理interrupt的任务。
  2. 不清楚任务是否支持取消。
  3. 需要等待已经开始的任务执行完成。

Future主要方法

• isDone():判断线程是否执行完成。
• isCancelled():判断是否被取消。

用法

• 用法1：线程池的submit方法返回Future对象：首先,我们要给线程池提交我们的任务,提交时线程池会立刻返回给我们一个空的Future容器。当线程的任务一旦执行完毕,也就是当我们可以获取结果的时候,线程池便会把该结果填入到之前给我们的那个Future中去(而不是创建一个新的Future ) ,我们此时便可以从该Future中获得任务执行的结果。
  
• 用法2:用FutureTask来创建Future：FutureTask取Future和任务的结果。FutureTask是一种包装器,可以把Callable转化成Future和Runnable,它同时实现二者的接口。
  把Callable实例当作参数,生成FutureTask的对象,然后把这个对象当作一个Runnable对象,用线程池或另起线程去执行这个Runnable对象,最后通过FutureTask获取刚才执行的结果。

• Future的注意点
  • 当for循环批量获取future的结果时,容易发生一部分线程很慢的情况,get方法调用时应使用timeout限制。
  • Future的生命周期不能后退：生命周期只能前进,不能后退。就和线程池的生命周期一样,一旦完全完成了任务,它就永久停在了"已完成"的状态,不能重头再来。

演示一个Future的使用方法

/**
 * 演示一个Future的使用方法
 */
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();
    }

    private static class CallableTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(2000);
            return new Random().nextInt();
        }
    }
}

演示一个Future的使用方法,Lambda表达式

/**
 * 演示一个Future的使用方法,Lambda表达式
 */
public class OneFutureLambda {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = () -> {
            Thread.sleep(2000);
            return new Random().nextInt();
        };
        //匿名内部类
//        Callable<Integer> callable1 = new Callable<Integer>() {
//            @Override
//            public Integer call() throws Exception {
//                Thread.sleep(2000);
//                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();
    }
}

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

/**
 * 演示批量提交任务，用list来批量接收结果
 */
public class MultiFutires {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(2);
        ArrayList<Future> futures = new ArrayList<>();
        for(int i=0;i<20;i++){
            Future<Integer> future = service.submit(new CallableTask());
            futures.add(future);
        }

        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();
            }
        }
        service.shutdown();
    }

    private static class CallableTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return new Random().nextInt();
        }
    }
}

演示get方法抛出异常

/**
 * 演示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异常");
        }
        service.shutdown();
    }
    private static class CallableTask implements Callable<Integer> {

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

演示get超时方法，需要注意超时后处理，调用future.cancel()

/**
 * 演示get超时方法，需要注意超时后处理，调用future.cancel()。演示cancel传入true和false的区别，代表是否中断正在进行的任务。
 */
public class TimeOut {
    private static final Ad DEFAULT_AD = new Ad("无网络的默认广告");
    private static final ExecutorService service = 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 FatchAdTask 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 = service.submit(new FatchAdTask());
        Ad ad;
        try {
            ad = f.get(2000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            ad = new Ad("被中断时候得默认广告");
            e.printStackTrace();
        } catch (ExecutionException e) {
            ad = new Ad("异常时候得默认广告");
            e.printStackTrace();
        } catch (TimeoutException e) {
            ad = new Ad("超时时候得默认广告");
            System.out.println("超时了，未获取到广告");

            boolean cancel = f.cancel(false);
//            boolean cancel = f.cancel(true);
            System.out.println("cancel的结果" + cancel);
        }
        service.shutdown();
        System.out.println(ad);
    }

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

演示FutureTask用法

/**
 * 演示FutureTask用法
 */
public class FutureTaskDemo {
    public static void main(String[] args) {
        Task task = new 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();
        }
    }

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