接口ExecutorService的方法使用

最新推荐文章于 2024-08-21 22:54:28 发布

细嗅蔷薇的大老虎

最新推荐文章于 2024-08-21 22:54:28 发布

阅读量559

点赞数 1

分类专栏： java并发编程文章标签： java 多线程 thread future

本文链接：https://blog.csdn.net/weixin_40472874/article/details/107765179

版权

java并发编程专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1.ExecutorService接口继承于Executor接口（线程池最顶层父类）,抽象类AbstractExecutorService实现了ExecutorService接口，最常用的线程池类ThreadPoolExecutor就是继承于AbstractExecutorService抽象类。
2.接口ExecutorService 中有很多工具方法，ExecutorService接口中的方法有些与 Future 和Callable有关，所以 Future与Callable 的使用是学习 ExecutorService 接口中方法的基础。

接口ExecutorService的完整实现与继承结构图

在这里插入图片描述

ExecutorService接口的全部API

在这里插入图片描述

ExecutorService接口的invokeAny()和 invokeAll()

1.方法 invokeAny（）和 invokeAll（）具有阻塞特性。
2.方法 invokeAny（）是取得第一个完成任务的结果值，当第一个任务执行完后，会调
interrupt（）方法将其他任务中断，所以在这些任务中可以结合
if (Thread.currentThread(). islnterrupted() ==true）代码来决定其余任务是否继续运行。
3.方法 invokeAll （）等全部线程任务执行完毕后，取得全部完成任务的结果值。

invokeAny()方法

invokeAny()执行后有2种情况：
(1) 无 if (Thread.currentThread().islnterrupted （））代码：已经获得第1个运行的结果值后，其他线程继续运行。
(2)有 if (Thread.currentThread().islnterrupted（））代码：已经获得第1个运行的结果值后，其他线程如果使用 throw new InterruptedException（）代码则这些线程中断，虽然 throw 抛出了异常，但在 main 线程中并不能捕获异常。如果想捕获异常，则需要在 Callable中使用 try-catch 显式进行捕获。

源码

//返回值不是List<Future<T>> 直接返回了Callable的返回值，不需要通过Future获取
//参数是Collection，也就是集合，泛型是extends Callable的类
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

<T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

invokeAny()执行的任务中，存在部分任务抛异常。

invokeAny()执行的任务中，如果存在部分任务抛异常，会放弃该任务，从其他任务中选取最先返回的值。

示例

public class ExecutorServiceDemo {
    //无异常任务
    public static class MyCallableA implements Callable {

        String name;
        long sleepTime;

        public MyCallableA(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
            return name + "执行完毕！";
        }
    }

    //异常任务
    public static class MyCallableB implements Callable{

        String name;
        long sleepTime;

        public MyCallableB(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
            Integer.parseInt("a");
            return name + "执行完毕！";
        }
    }

    public static void main(String[] args) {
        try {
            ExecutorService es = Executors.newCachedThreadPool();
            List list = new ArrayList<Callable>();
            //正常任务，不抛异常
            list.add(new MyCallableA("任务1",2000));
            //抛异常任务，该任务先执行完
            list.add(new MyCallableB("任务2",1000));
            //MyCallableB任务抛异常，只能获取MyCallableA的值
            Object result = es.invokeAny(list);
            System.out.println(result);
            System.out.println("结束！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

任务1执行完毕！
结束！

由实验可知，MyCallableB抛异常之后，invokeAny把关注点放在了其他任务上，并不影响，main主线程也不受影响，正常执行，invokeAny有堵塞效果，在等待任务返回值返回时，后面代码无法执行。

invokeAny()执行的任务中，存在全部任务抛异常。

当一个任务抛异常后，invokeAny会从其他任务中获取最先返回的值，如果再有任务抛异常，会再次从现在剩余的任务中获取最先返回的值，直到所有的任务都抛异常，没有其他任务，此时invokeAny会将任务的异常在主线程抛出。

public class ExecutorServiceDemo {
    //异常任务
    public static class MyCallableA implements Callable {

        String name;
        long sleepTime;

        public MyCallableA(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
            Integer.parseInt(name);
            return name + "执行完毕！";
        }
    }

    //异常任务
    public static class MyCallableB implements Callable{

        String name;
        long sleepTime;

        public MyCallableB(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
            Integer.parseInt(name);
            return name + "执行完毕！";
        }
    }

    public static void main(String[] args) {
        try {
            ExecutorService es = Executors.newCachedThreadPool();
            List list = new ArrayList<Callable>();
            //抛异常任务，该任务后执行完
            list.add(new MyCallableA("任务1",2000));
            //抛异常任务，该任务先执行完
            list.add(new MyCallableB("任务2",1000));
            //两个任务都抛异常，获取最后抛异常的任务的错误信息
            Object result = es.invokeAny(list);
            System.out.println(result);
            System.out.println("结束！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

com.minxl.demo.multiThread.ExecutorServiceDemo
java.util.concurrent.ExecutionException: java.lang.NumberFormatException: For input string: "任务1"
	at java.util.concurrent.FutureTask.report(FutureTask.java:122)
	at java.util.concurrent.FutureTask.get(FutureTask.java:192)
	at java.util.concurrent.AbstractExecutorService.doInvokeAny(AbstractExecutorService.java:193)
	at java.util.concurrent.AbstractExecutorService.invokeAny(AbstractExecutorService.java:215)
	at com.minxl.demo.multiThread.ExecutorServiceDemo.main(ExecutorServiceDemo.java:63)
Caused by: java.lang.NumberFormatException: For input string: "任务1"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at com.minxl.demo.multiThread.ExecutorServiceDemo$MyCallableA.call(ExecutorServiceDemo.java:29)
	at com.minxl.demo.multiThread.ExecutorServiceDemo$MyCallableA.call(ExecutorServiceDemo.java:15)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)

由实验可知，MyCallableB抛异常，invokeAny只能获取MyCallableA的值，后来MyCallableA也抛异常，最终将MyCallableA的异常在主线程抛出，中断主线程的代码执行。

方法 invokeAny(CollectionTasks,timeout,timeUnit）超时的测试

方法＜T> T invokeAny(Collection< ? extends Callable> tasks, long timeout, TimeUnit unit) 主要作用就是在指定时间内取得第1个先执行完的任务的结果值，取到之后中断其他任务线程（需要配合if(Thread.currentThread().isInterrupted() == true)代码）。如果没有取到返回值，超时了，主线程会报异常TimeoutException，然后中断所有任务线程（需要配合if(Thread.currentThread().isInterrupted() == true）代码。

示例

public class ExecutorServiceDemo {
    //任务
    public static class MyCallableA implements Callable {

        String name;
        long sleepTime;

        public MyCallableA(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            while(1==1){
                if(Thread.currentThread().isInterrupted() == true){
                    System.out.println(name+"被中断！");
                    break;
                }
            }
            return name + "执行完毕！";
        }
    }

    //任务
    public static class MyCallableB implements Callable{

        String name;
        long sleepTime;

        public MyCallableB(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            while(1==1){
                if(Thread.currentThread().isInterrupted() == true){
                    System.out.println(name+"被中断！");
                    break;
                }
            }
            return name + "执行完毕！";
        }
    }

    public static void main(String[] args) {
        try {
            ExecutorService es = Executors.newCachedThreadPool();
            List list = new ArrayList<Callable>();
            //不会返回值
            list.add(new MyCallableA("任务1",2000));
            //不会返回值
            list.add(new MyCallableB("任务2",1000));
            //两个任务都不会返回值，main抛异常，invokeAny中断所有任务
            Object result = es.invokeAny(list,2, TimeUnit.SECONDS);
            System.out.println(result);
            System.out.println("结束！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

任务2被中断！
任务1被中断！
java.util.concurrent.TimeoutException
	at java.util.concurrent.AbstractExecutorService.doInvokeAny(AbstractExecutorService.java:184)
	at java.util.concurrent.AbstractExecutorService.invokeAny(AbstractExecutorService.java:225)
	at com.minxl.demo.multiThread.ExecutorServiceDemo.main(ExecutorServiceDemo.java:72)

invokeAll()方法

1.方法 invokeAll()返回所有任务的执行结果,并且此方法的效果是阻塞执行的
，要把所有的结果都取回再继续向下运行。
2.invokeAll方法返回值放在List<Future<T*>>中，list存放任务的顺序与放入任务的顺序一致，等所有任务都结束才会返回List<Future<T*>>
3.子任务（Callable任务）抛异常时，只有调用Future.get()方法，才能抛出，进而被主线程捕获。

源码

//返回值时list,里面存放Future对象，返回值还得从Future里get()方法获取。
//参数还是Collection集合，且是Callable实现类的集合
List<Future<T>> invokeAll(Collection<? extends Callable<T>> var1) throws InterruptedException;

List<Future<T>> invokeAll(Collection<? extends Callable<T>> var1, long var2, TimeUnit var4) throws InterruptedException;

方法 invokeAll(Collection tasks）中存在任务线程异常

public class ExecutorServiceDemo {
    //无异常任务
    public static class MyCallableA implements Callable {
        String name;
        long sleepTime;

        public MyCallableA(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
            System.out.println(name+"执行完，准备返回值");
            return name + "执行完毕！";
        }
    }

    //异常任务
    public static class MyCallableB implements Callable{
        String name;
        long sleepTime;

        public MyCallableB(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
            Integer.parseInt(name);
            System.out.println(name+"执行完，准备返回值");
            return name + "执行完毕！";
        }
    }

    public static void main(String[] args) {
        try {
            ExecutorService es = Executors.newCachedThreadPool();
            List list = new ArrayList<Callable>();
            //后执行完，无异常
            list.add(new MyCallableA("任务1",2000));
            //先执行完，抛异常
            list.add(new MyCallableB("任务2",1000));
            //执行任务
            List<Future> result = es.invokeAll(list);
            for(Future future : result){
                System.out.println(future.get());
            }
            System.out.println("结束！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

任务1执行完，准备返回值
任务1执行完毕！
java.util.concurrent.ExecutionException: java.lang.NumberFormatException: For input string: "任务2"
	at java.base/java.util.concurrent.FutureTask.report(FutureTask.java:122)
	at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:191)
	at com.example.demo.ExecutorServiceDemo.main(ExecutorServiceDemo.java:58)
Caused by: java.lang.NumberFormatException: For input string: "任务2"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.base/java.lang.Integer.parseInt(Integer.java:652)
	at java.base/java.lang.Integer.parseInt(Integer.java:770)
	at com.example.demo.ExecutorServiceDemo$MyCallableB.call(ExecutorServiceDemo.java:41)
	at com.example.demo.ExecutorServiceDemo$MyCallableB.call(ExecutorServiceDemo.java:28)
	at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
	at java.base/java.lang.Thread.run(Thread.java:834)

任务2先执行完，等待任务1执行完，按顺序放入结果List<Future*>中，遍历获取值时先正确获取任务1返回值，再获取任务2返回值抛异常，中断main线程。

方法 invokeAll(Collection tasks,long timeout,TimeUnit unit)

方法 invokeAll(Collection tasks,long timeout,TimeUnit unit）的作用是如果任务在指定的时间内没有完成，则出现异常：CancellationException。
1.如果前面的任务没有执行完，在Future.get()时会抛异常CancellationException，代码不在往下执行。
2.如果后面的任务没有执行完，在Future.get()时前面规定时间内，返回值的会正常获取，后面没执行完的会抛异常CancellationException，代码不在往下执行。

示例：先快后慢

public class ExecutorServiceDemo {
    //任务
    public static class MyCallableA implements Callable {
        String name;
        long sleepTime;

        public MyCallableA(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
            System.out.println(name+"执行完，准备返回值");
            return name + "执行完毕！";
        }
    }

    //任务
    public static class MyCallableB implements Callable{
        String name;
        long sleepTime;

        public MyCallableB(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
           // Integer.parseInt(name);
            System.out.println(name+"执行完，准备返回值");
            return name + "执行完毕！";
        }
    }

    public static void main(String[] args) {
        try {
            ExecutorService es = Executors.newCachedThreadPool();
            List list = new ArrayList<Callable>();
            //先执行完
            list.add(new MyCallableA("任务1",900));
            //规定时间没执行完，被中断
            list.add(new MyCallableB("任务2",1500));
            //执行任务
            List<Future> result = es.invokeAll(list,1,TimeUnit.SECONDS);
            for(Future future : result){
                System.out.println(future.get());
            }
            System.out.println("结束！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

任务1执行完，准备返回值
任务1执行完毕！
java.util.concurrent.CancellationException
	at java.base/java.util.concurrent.FutureTask.report(FutureTask.java:121)
	at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:191)
	at com.example.demo.ExecutorServiceDemo.main(ExecutorServiceDemo.java:58)

上面例子中，任务1在规定时间内执行完，返回值，任务2没执行完被中断，主线程调用时抛异常CancellationException。
示例：先慢后快

public class ExecutorServiceDemo {
    //任务
    public static class MyCallableA implements Callable {
        String name;
        long sleepTime;

        public MyCallableA(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
            System.out.println(name+"执行完，准备返回值");
            return name + "执行完毕！";
        }
    }

    //任务
    public static class MyCallableB implements Callable{
        String name;
        long sleepTime;

        public MyCallableB(String name,long sleepTime) {
            super();
            this.name = name;
            this.sleepTime = sleepTime ;
        }

        @Override
        public String call() throws Exception {
            Thread.sleep(sleepTime);
           // Integer.parseInt(name);
            System.out.println(name+"执行完，准备返回值");
            return name + "执行完毕！";
        }
    }

    public static void main(String[] args) {
        try {
            ExecutorService es = Executors.newCachedThreadPool();
            List list = new ArrayList<Callable>();
            //后执行完，被中断
            list.add(new MyCallableA("任务1",1500));
            //先执行完
            list.add(new MyCallableB("任务2",900));
            //执行任务
            List<Future> result = es.invokeAll(list,1,TimeUnit.SECONDS);
            for(Future future : result){
                System.out.println(future.get());
            }
            System.out.println("结束！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
任务2执行完，准备返回值
java.util.concurrent.CancellationException
	at java.base/java.util.concurrent.FutureTask.report(FutureTask.java:121)
	at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:191)
	at com.example.demo.ExecutorServiceDemo.main(ExecutorServiceDemo.java:58)