接口ExecutorService的方法使用

1.ExecutorService接口继承于Executor接口（线程池最顶层父类）,抽象类AbstractExecutorService实现了ExecutorService接口，最常用的线程池类ThreadPoolExecutor就是继承于AbstractExecutorService抽象类。

2.接口ExecutorService 中有很多工具方法，ExecutorService接口中的方法有些与 Future 和Callable有关，所以 Future与Callable 的使用是学习 ExecutorService 接口中方法的基础。

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

ExecutorService接口的全部API

接口ExecutorService的方法使用

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)

任务2先执行完，任务1规定时间没执行完，但是Future.get()先获取任务1的值，则直接抛异常CancellationException，后面代码无法执行，任务2的值没返回。

总结

接口 ExecutorService 中的方法都以便携的方式去创建线程池，使用两个主要的方法invokeAny（）和 invokeAll（）来取得第一个首先执行完任务的结果值，以及全部任务的结果值。

接口ExecutorService的方法使用

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

ExecutorService接口的全部API

ExecutorService接口的invokeAny()和 invokeAll()

invokeAny()方法

源码

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

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

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

invokeAll()方法

源码

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

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

总结

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method