管理线程工具类（1）：Future和Callable

其他 2020-02-08 10:45:07 阅读次数: 0

1 Runnable的缺陷

  • 不能返回一个返回值
  • 也不能抛出checked Exception
  • 为什么有这样的缺陷？
  • Runnable为什么设计成这样？
  • 针对于无法抛岀检査后异常这个缺陷的补救措施
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
/**
 * 在run方法中无法抛出checked Exception
 */
public class RunnableCantThrowsException {
    public void ddd() throws Exception {
        throw new Exception();
    }
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                //throw new Exception();
                try {
                    throw new Exception();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
    }
}

2 Callable接口

  • 类似于Runnable，被其它线程执行的任务
  • 实现call方法
  • 有返回值
@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

3 Future类

Future的作用

3.1 Callable和Future的关系

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

3.2 Future的主要方法：一共5个

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

3.2.1 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
  • 超时不获取，任务需取消

3.3.2 isDone

isDone()方法：判断线程是否执行完毕（不代表执行成功，只是代表以后这个任务不会在执行了）

3.2.3 cancel方法：取消任务的执行

  1. 如果这个任务还没有开始执行，那么这种情况最简单，任务会被正常的取消，未来也不会被执行，方法返回true。
  2. 如果任务已完成，或者已取消：那么cancel()方法会执行失败，方法返回false。
  3. 如果这个任务已经开始执行了，那么这个取消方法将不会直接取消该任务，而是会根据我们填的参数 mayInterruptIfRunning做判断（true：发出中断，false：正常执行到结束，true/false都只是针对任务正在进行中的情况）。

Future.cancel(true)适用于：

  1. 任务能够处理interrupt

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

  1. 未能处理interrupt的任务
  2. 不清楚任务是否支持取消
  3. 需要等待已经开始的任务执行完成

3.2.4 isCancelled

 isCancelled()方法：判断是否被取消

4 用法1：线程池的submit方法返回Future对象，6个代码演示

4.1 get基本用法

首先，我们要给线程池提交我们的任务，提交时线程池会立刻返回给我们一个空的Future容器。当线程的任务一旦执行完毕，也就是当我们可以获取结果的时候，线程池便会把该结果填入到之前给我们的那个Future中去（而不是创建一个新的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();
    }
    static class CallableTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return new Random().nextInt();
        }
    }
}

4.2 Callable的Lambda表达式形式

/**
 * 演示一个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);
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }
}

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

 4.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抛出异常");
        }
    }
}

4.5 获取任务超时

/**
 * 演示get的超时方法，需要注意超时后处理，调用future.cancel()。演示cancel传入true和false的区别，代表是否中断正在执行的任务。
 */
public class Timeout {
    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("超时，未获取到广告");
            //true：如果线程还在运行就中断线程
            //false：正常执行一直到结束
            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();
    }
}

5 用法2：用FutureTask来创建Future

  • 用FutureTask来获取Future和任务的结果
  • FutureTask是一种包装器，可以把Callable转化成Future和Runnable，它同时实现二者的接口
  • 所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

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

/**
 * 演示FutureTask的用法
 */
public class FutureTaskDemo {
    public static void main(String[] args) {
        Task task = new Task();
        FutureTask<Integer> integerFutureTask = new FutureTask<>(task);
        //1.创建线程传入FutureTask
        new Thread(integerFutureTask).start();
        //2.使用线程池提交
        //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;
    }
}

6 Future的注意点

当for循环批量获取future的结果时，容易发生一部分线程很慢的情況，get方法调用时应使用timeout限制

Future的生命周期不能后退

  • 生命周期只能前进，不能后退。就和线程池的生命周期一样，一旦完全完成了任务，它就永久停在了 “已完成” 的状态，不能重头再来
嘤 嘤 嘤
发布了533 篇原创文章 · 获赞 898 · 访问量 111万+
他的留言板 关注

猜你喜欢

转载自blog.csdn.net/qq_40794973/article/details/104137801
今日推荐
周排行
成为C++高手之宏与枚举
在CAD二次开发中使用进度条
Js插件ECharts，HighCharts学习网址整理
Celery提交任务出错(on windows.)
cephfs内核客户端性能追踪
thinkphp中PHPExcel用法
EntityFramework动态组合多排序字段
汇编语言（八）实验9 根据材料编程
安装ubuntu后必须做的事情（对我而言）
JS函数式编程
每日归档
更多
2024-10-22(0)
2024-10-21(0)
2024-10-20(0)
2024-10-19(0)
2024-10-18(0)
2024-10-17(0)
2024-10-16(0)
2024-10-15(0)
2024-10-14(0)
2024-10-13(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022