专栏首页desperate633Java并发之Executor(返回结果处理)运行多个任务并处理第一个结果运行多个任务并处理所有结果

Java并发之Executor(返回结果处理)运行多个任务并处理第一个结果运行多个任务并处理所有结果

  • 运行多个任务并处理第一个结果
  • 运行多个任务并处理所有结果

运行多个任务并处理第一个结果

并发编程常见的问题,就是当采用多个并发任务来解决一个问题,我们往往只对第一个返回的结果有兴趣。比如,对一个数组有多种排序算法,可以并发启动所有算法,但是对于一个给定的数组,第一个得到排序结果的算法就是最快的排序算法。

我们通过一个实例,这个实例会发起两种验证任务,只要有一个任务验证通过,就通过。

实现验证过程的类,逻辑很简单,不管是什么用户名,都是随机验证的,随机返回一个boolean。

package CreateExcutorInvokeAny;

import java.util.Random;
import java.util.concurrent.TimeUnit;

public class UserValidator {
    private String name;
    
    public UserValidator (String name) {
        this.name = name;
    }
    
    public boolean validate(String name,String password) {
        Random random = new Random();
        
        Long duration = (long)Math.random()*10;
        System.out.printf("Validator %s : Validator a user during %d seconds\n", 
                this.name, duration);
        try {
            TimeUnit.SECONDS.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
            return false;
        }
        
        return random.nextBoolean();
    }
    
    public String getName() {
        return this.name;
    }
}

Callable对象,他的逻辑是如果验证通过,就返回结果,如果验证不通过,就抛出异常。

package CreateExcutorInvokeAny;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;

public class TaskValidator implements Callable<String> {
    
    private UserValidator validator;
    
    private String user;
    private String password;
    
    

    public TaskValidator(UserValidator validator, String user, String password) {
        super();
        this.validator = validator;
        this.user = user;
        this.password = password;
    }



    @Override
    public String call() throws Exception {
        if(!validator.validate(user, password)) {
            System.out.println(validator.getName() + "the user has not been found");
            throw new Exception("Error validating user");
        }
        System.out.println(validator.getName() + "has found");
        return validator.getName();
    }
    
}

Main类

package CreateExcutorInvokeAny;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {

    public static void main(String[] args) {
        String username = "test";
        String password = "test";
        UserValidator oneValidator = new UserValidator("one");
        UserValidator twoValidator = new UserValidator("two");
        TaskValidator oneTask = new TaskValidator(oneValidator, username, password);
        TaskValidator twoTask = new TaskValidator(twoValidator, username, password);
        List<TaskValidator> taskList = new ArrayList<>();
        taskList.add(oneTask);
        taskList.add(twoTask);
        
        ExecutorService executor = Executors.newCachedThreadPool();
        String res;
        
        try {
            res = executor.invokeAny(taskList);
            System.out.println("Main : res : " + res);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        
        executor.shutdown();
        System.out.println("Main : end of the execution");
    }

}

这里的关键步骤就是invokeAny这个方法,会返回第一个执行结束的任务的结果,也就是说,如果验证没通过,任务无法执行完成,自然就不会完成,就不会返回,如果验证通过了,就会返回结果。

我们分析程序,会有四种可能性:

  • 如果两个任务都返回true,也就是都验证通过,那么invokeany会返回第一个通过的结果
  • 如果第一个任务验证返回true,第二个任务抛出exception,那么invokeAny方法的结果就是第一个任务的名称
  • 如果第一个任务抛出异常,第二个任务返回true,那么第二个任务的结果就是返回结果
  • 最后就是,两个任务都抛出异常,那么invokeAny方法也会抛出异常

image.png

image.png

image.png

image.png

运行多个任务并处理所有结果

Executor允许执行并发的任务而不需要去考虑线程创建和执行 如果想要等待线程结束,有以下两种方法:

  • 如果任务执行结束,那么Future接口的isDone方法将返回true
  • 在调用shutdown方法之后,ThreadPoolExecutor类的awaitTermination方法会将线程休眠,直到所有任务执行结束

使用invokeall方法就可以执行所有任务,这个方法会等到所有任务执行完成之后,再返回。

我们看一个实例:

package CreateExecutorInvokeAll;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class Task implements Callable<Result> {
    
    private String name;
    
    public Task(String name) {
        this.name = name;
    }
    
    @Override
    public Result call() throws Exception {
        System.out.println(this.name + " Starting\n");
        
        Long duration = (long)Math.random()*10;
        System.out.printf("Validator %s : Validator a user during %d seconds\n", 
                this.name, duration);
        try {
            TimeUnit.SECONDS.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        int value = 0;
        for(int i=0;i<5;i++) {
            value += (int)Math.random()*100;
        }
        
        Result res = new Result();
        res.setName(this.name);
        res.setValue(value);
        
        System.out.println(this.name + " end");
        return res;
    }
    
}
package CreateExecutorInvokeAll;

public class Result {
    
    private String name;
    private int value;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
    
    
}
package CreateExecutorInvokeAll;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {

    public static void main(String[] args) {
        
        ExecutorService executor = Executors.newCachedThreadPool();
        
        List<Task> tasklist = new ArrayList<>();
        
        for(int i=0;i<3;i++) {
            Task task = new Task(String.valueOf(i));
            tasklist.add(task);
        }

        List<Future<Result>> reslist = new ArrayList<>();
        
        try {
            reslist = executor.invokeAll(tasklist);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        executor.shutdown();
        
        System.out.println("Main : res");
        
        for(int i=0;i<reslist.size();i++) {
            Future<Result> future = reslist.get(i);
            
            try {
                Result res = future.get();
                System.out.println("result : " + res.getName() + "||" + res.getValue());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

}

运行结果

image.png

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 设计模式之代理模式(Proxy模式)代理模式的引入代理模式的实例程序代理模式分析

    Proxy是代理人的意思,指的是代替别人进行工作的人。当不一定需要本人亲自去做的工作的时候,就可以寻找代理人去完成。 但在代理模式中,往往是相反的,通常是代理...

    desperate633
  • Java Iterable 与 Iterator

    但实际中,我们不需要这么麻烦,因为所有collection都有一个iterator()方法,在JDK1.4之前这个方法定义在collection接口中的,因此所...

    desperate633
  • Serialization in JavaSerializable in JavaClass Refactoring with Serialization and serialVersionUIDJa

    我们知道Java对象的生存周期跟GC有关,更宽泛一点讲,JVM关闭了,对象自然也就被销毁了。但是有的时候,我们需要将某些对象保存起来,或者进行传输,以便以后JV...

    desperate633
  • Spring Boot+JPA+Mysql完成数据库整合操作

    Spring Boot结合JPA操作Mysql数据库十分方便,可以做到零配置文件。具体流程如下。

    itlemon
  • (四)SpringBoot2.0基础篇- 多数据源,JdbcTemplate和JpaRepository

  • Spring框架系列(二)之Bean的注解管理

    微信公众号:compassblog 欢迎关注、转发,互相学习,共同进步! 有任何问题,请后台留言联系! 1、Spring中的两种容器 在系列(一)中我们已经知道...

    compassblog
  • 第80节:Java中的MVC设计模式

    事务,设置自动连接提交关闭. setAutoCommit(false); conn.commit(); conn.rollBack

    达达前端
  • ssh搭建开发环境

    公司一直不是ssh零配置的框架,每次写action都要在applicationcontext和struts里面配置,好麻烦,最近有空,写了一个ssh零配置的框架...

    xiangzhihong
  • java架构之路-(spring源码篇)由浅入深-spring实战详细使用

      今天我更新了一篇jvm垃圾回收的算法和垃圾回收器的内部逻辑,但是看的人不多啊......貌似大家还是比较喜欢看源码吧,毕竟实战要比理论用的多。

    小菜的不能再菜
  • 由浅入深,讲解 spring 实战详细使用——spring 源码篇

    首先,这篇文章不会详细的深入底层源码,只是基于注解和配置来说说我们的 spring 的使用,别小看基础,保证有你没用过的注解和配置,走起。

    淡定的蜗牛

扫码关注云+社区

领取腾讯云代金券