JUC并发编程(九)——Future和Callable(获取子线程结果)

Callable和Future的介绍

Runnable的缺陷

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

Callable接口

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

Future的作用
核心思想是创建一个子线程执行一个事件，主线程不需要等待该事件的执行，但是主线程可以随时拿到子线程的执行结果。

Callable和Future的关系

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

Future的主要方法

get()方法：获取结果
get方法的行为取决于Callable任务的状态，只有以下这5种情况：
任务正常完成：get方法会立刻返回结果
任务尚未完成（任务还没开始或进行中）：get将阻塞并直至任务完成。
任务执行过程中抛出Exception：get方法会抛出ExecutionException：这里的抛出异常，是call()执行时产生的那个异常，看到这个异常类型是java.util.concurrent.ExecutionException。不论call0执行时抛出的异常类型是什么，最后get方法抛出的异常类型都是ExecutionException。
任务被取消：get方法会抛出CancellationException
5.任务超时：get方法有一个重载方法，是传入一个延迟时间的，如果时间到了还没有获得结果，get方法就会抛出TimeoutException。
get(long timeout, TimeUnit unit)：有超时的获取
用get(long timeout, TimeUnit unit)方法时，如果call()在规定时间内完成了任务，那么就会正常获取到返回值；而如果再指定时间内没有计算出结果，那么就会抛出TimeoutException
超时不获取，任务需取消
cancel方法
取消任务的执行

如果这个任务还没有开始执行，那么这种情况最简单，任务会被正常的取消，未来也不会被执行，方法返回true。
如果任务已完成，或者已取消：那么cancel()方法会执行失败，方法返回false.
如果这个任务已经开始执行了，那么这个取消方法将不会直接取消该任务，而是会根据我们填的参数maylnterruptlfRunning做判断。

Future.cancel(true)适用于：
1).任务能够处理interrupt

Future.cancel(false) 仅用于避免启动尚未启动的任务，适用于：
1).未能处理interrupt的任务
2).不清楚任务是否支持取消
3).需要等待已经开始的任务执行完成

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

JUC并发编程(九)——Future和Callable(获取子线程结果)-Nickの博客

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

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

package future;

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

/**
 * 描述：     演示一个Future的使用方法
 */
public class OneFuture {

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        Future<Integer> future = service.submit(new CallableTask());
        System.out.println("可以先做其他操作，，，");
        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();
        }
    }
}

lambda形式或者匿名函数形式

package future;

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

/**
 * 描述：     演示一个Future的使用方法,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);
        System.out.println("可以先做其他操作，，，");
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }

}

运行结果：
JUC并发编程(九)——Future和Callable(获取子线程结果)-Nickの博客

案例：get的超时方法后处理，cancel传入true和false的区别

package future;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * 描述：     演示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("超时，未获取到广告");
            boolean cancel = f.cancel(true);
            System.out.println("cancel的结果：" + cancel);
        }
        exec.shutdown();
        System.out.println(ad);
    }

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

运行结果：
JUC并发编程(九)——Future和Callable(获取子线程结果)-Nickの博客
可以看到，cancel传true的时候，线程被中断了。

用法2：用FutureTask来创建Future

FutureTask
所以它既可以作为Runnable被线程执行，又可以作为Future
得到Callable的返回值

JUC并发编程(九)——Future和Callable(获取子线程结果)-Nickの博客

把Callable实例当作参数，生成FutureTask的对象，然后把这个对象当作一个Runnable对象，用线程池或另起线程去执行这个Runnable对象，最后通过FutureTask获取刚才执行的结果

Future和FutureTask区别
Future 是一个接口，用于表示异步计算的结果，不能直接实例化，通常由线程池的 submit() 方法返回。
FutureTask 是 Future 的一个具体实现类，它既可以作为任务执行，也可以获取任务的执行结果。它是 Runnable 和 Future 的结合体，提供了更灵活的使用方式。

FutureTask的用法

package future;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.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();
        }
    }
}

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

Future的注意点

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

JUC并发编程(九)——Future和Callable(获取子线程结果)

Callable和Future的介绍

Future的主要方法

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

用法2：用FutureTask来创建Future

Future的注意点

JUC并发编程(八)——AQS(并发灵魂)

JUC并发编程(七)——控制并发流程

JUC并发编程(六)——并发容器

JUC并发编程(五)——CAS原理&final不变性