Java并发JUC——Future和Callable

标签：Java get Callable 任务 Future 线程 执行 public

Runnable的缺陷

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

Callable接口

• 类似于Runnable，被其他线程执行的任务
• Callable接口中只有一个call()方法，和Runnable相比，该方法有返回值并允许抛出异常

Future类

Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。

Callable和Future的关系

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

Future的主要方法

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

 

Future<V>接口是用来获取异步计算结果的，说白了就是对具体的Runnable或者Callable对象任务执行的结果进行获取(get())，取消(cancel())，判断是否完成等操作。

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个方法，下面依次解释每个方法的作用：

• get()：用来获取执行结果，get方法的行为取决于Callable任务的状态，只有一下这5中情况：
  • 1、任务正常完成：get方法会立刻返回结果
  • 2、任务尚未完成(任务还没开始或在执行中)：get将阻塞并直到任务完成
  • 3、任务在执行的过程中抛出Exception：get方法会抛出ExecutionException：这里的抛出异常，是call()执行时产生的那个异常，看到这个异常的类型是java.util.concurrent.ExecutionException。不论call()执行时抛出的异常类型是什么，最后get方法抛出的异常类型都是ExecutionException
  • 4、任务被取消：get方法会抛出CancellationException
  • 5、任务超时：get方法有一个重载方法，是传入一个延迟时间，如果时间到了还没有获得结果，get方法就会抛出TimeoutException
• get(long timeout, TimeUnit unit)：有超时的获取执行结果
  • 超时的需求很常见
  • 用get(long timeout, TimeUnit unit)方法时，如果call()在规定的时间内完成了任务，那么就会正常的获取到返回值，；而如果在指定的时间内没有计算出返回结果，那么就会抛出TimeoutException
  • 超时不获取，任务需取消
• cancel()：用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
• isDone()：表示任务是否已经执行完毕，若任务执行完毕，则返回true；但是执行完毕不代表成功执行
• isCancelled()：表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。

get基本用法

用法1、线程池的submit()方法返回Future对象

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

public class FutureDemo2 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = () -> {
            Thread.sleep(3000);
            return new Random().nextInt();
        };
        Future<Integer> future = executorService.submit(callable);
        try {
            Integer integer = future.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
    }
}

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

/**
 * @Description: 演示批量提交任务时，用List来批量获取结果
 */
public class FutureDemo3 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(20);

        ArrayList<Future<Integer>> list = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            Future<Integer> future = executorService.submit(() -> {
                Thread.sleep(3000);
                return new Random().nextInt();
            });
            list.add(future);
        }

        for (int i = 0; i < list.size(); i++) {
            Future<Integer> future = list.get(i);
            System.out.println(future.get());
        }

        executorService.shutdown();
    }
}

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

/**
 * @Description:
 * 演示Future get过程中抛出异常，
 * for循环为了演示抛出Exception的时机，并不是说一产生异常就抛出，直到get执行时，才会抛出
 *
 */
public class FutureDemo4 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(20);

        Future<Integer> future = executorService.submit(() -> {
            throw new IllegalArgumentException("callable抛出异常");
        });

        try {
            for (int i = 0; i < 5; i++) {
                System.out.println(i);
                Thread.sleep(1000);
            }
            System.out.println(future.isDone());

            Integer integer = future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("InterruptedException");
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.out.println("ExecutionException");
        }

        executorService.shutdown();
    }
}

获取任务超时

/**
 * @Description:
 * 演示Future get的超时方法，需要注意超时后处理，调用future.cancel()，
 * 演示cancel()方法传入true和false的区别，代表是否中断正在执行的任务
 */
public class FutureDemo5 {

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

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

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

    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(){
        Ad ad;
        Future<Ad> future = executorService.submit(new FetchAdTask());
        try {
            ad = future.get(2000,TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
            ad = new Ad("InterruptedException，被中断时候的默认广告");
        } catch (ExecutionException e) {
            e.printStackTrace();
            ad = new Ad("异常时候的默认广告");
        } catch (TimeoutException e) {
            ad = new Ad("超时时候的默认广告");//超时时候的默认兜底
            System.out.println("超时了，未获取到广告");
            //超时中断执行
            boolean cancel = future.cancel(true);
            System.out.println("cancel的结果："+cancel);
        }
        executorService.shutdown();
        System.out.println(ad);
    }
}

cancel()方法：取消任务的执行

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

Future.cancel(true)适用于：

• 1、任务能够处理Interrupt(中断)

Future.cancel(false)仅用于避免启动尚未启动的任务，适用于：

• 未能处理Interrupt(中断)的任务
• 不清楚任务是否支持取消
• 需要等待已经开始的任务执行完成

用法2、用FutureTask来创建Future

• 用FutureTask来获取Future和任务的结果
• FutureTask是一种包装器，可以把Callable转化为Future和Runnable，它同时实现二者的接口
• 所以，它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
• 把Callable实例当做参数，生成FutureTask的对象，然后把这个对象当做一个Runnable对象，用线程池或另起一个线程去执行这个Runnable对象，最后通过FutureTask获取刚刚执行的结果

FutureTask的使用，启动线程的方式

/**
 * @Description: 演示FutureTask的用法，启动线程的方式
 */
public class FutureTaskDemo1 {

    public static void main(String[] args) {
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<>(task);
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

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

FutureTask的使用，线程池方式

/**
 * @Description: 演示FutureTask的用法,线程池方式
 */
public class FutureTaskDemo2 {

    public static void main(String[] args) {
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<>(task);
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(task);
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

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

Future的注意点

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

参考： https://www.cnblogs.com/xiaoxi/p/8303574.html

https://www.cnblogs.com/frankltf/p/10554932.html

标签：Java,get,Callable,任务,Future,线程,执行,public
From： https://blog.51cto.com/u_14014612/6029862