Java并发编程高级篇(四)：运行多个任务并处理第一个结果

接下来，我们来模拟一个用户验证过程，提供两种验证机制，任何一种验证机制验证成功即可通过验证，而不用等两种验证机制都验证成功。

创建UserValidator类，它通过休眠一个随机时间来模拟用户验证过程。

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

/**
 * Created by hadoop on 2016/11/2.
 */
public class UserValidator {
    private String name;

    public UserValidator(String name) {
        this.name = name;
    }

    public boolean validate(String username, String password) {
        long duration = (long) (Math.random() * 10);

        System.out.printf("Validator %s: validating a user during %d seconds\n", name, duration);

        try {
            TimeUnit.SECONDS.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return new Random().nextBoolean();
    }

    public String getName() {
        return name;
    }
}

接下来我们创建一个Callable类，用于调用验证模块来实现用户验证，验证成功后，返回当前验证方式名称，验证失败则抛出异常。

import java.util.concurrent.Callable;

/**
 * Created by hadoop on 2016/11/2.
 */
public class TaskValidator implements Callable {
    private UserValidator validator;

    private String username;
    private String password;

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

    @Override
    public String call() throws Exception {
        if (!validator.validate(username, password)) {
            System.out.printf("%s: The username has not been found\n", validator.getName());
            throw new Exception("Error validating user");
        }

        System.out.printf("%s: The username has been found\n", validator.getName());

        return validator.getName();
    }
}

最后创建主线程类。在主线程类中初始化两个验证器，然后启动两个验证线程来进行用户验证。调用invokeAny()方法，这个方法接收一个List作为参数，当有任何一个线程执行完毕后，直接返回这个线程的返回值。

• 第一个完成的验证器验证成功，则返回第一个完成的验证器的名称。
• 第一个完成的验证器验证失败，第二个完成的验证器验证成功，再返回第二个完成的验证器名称。
• 两个验证器都验证失败，那么invokeAny()返回ExecutionException。

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

/**
 * 4.5 运行多个任务并处理第一个结果
 *
 * 并发编程中常见一个的一个问题是，当采用并发任务来解决一个问题的时候，往往只考虑第一个返回的结果。
 * 比如使用多个线程采用不同的排序算法对数组进行排序，我们只关心第一个排序完成的线程，它是最快的算法。
 *
 * 在本节我们使用ThreadPoolExecutor类来实现这个场景。
 * 模拟使用两种方式对用户进行验证，但是只要有一种机制验证成功，那么就算验证通过。
 *
 * 这个范例的关键点在Main主类中：我们调用了ExecutorService的invokeAny()方法。
 * 这个方法接收一个任务列表，然后运行任务，并且返回第一个完成并且没有抛出异常的任务执行结果。
 * 这个方法的返回类型与任务重call()方法的返回类型相同。在这里返回String类型。
 *
 * 范例中定义了两个UserValidator对象，他们返回随机的boolean值。
 * 两个UserValidator对象分别被两个TaskValidator任务调用，用来验证用户。
 * 如果UserValidator对象的validate方法返回false那么抛出异常，那么TaskValidator抛出异常，否则返回当前UserValidator名字。
 *
 * 1. 如果两个UserValidator都验证通过，那么invokeAny()返回第一个完成的TaskValidator的执行结果。
 * 2. 如果第一个任务验证通过，第二个任务抛出异常，那么invokeAny()返回第一个完成的TaskValidator的执行结果。
 * 3. 如果第一个任务抛出异常，第二个任务验证通过，那么invokeAny()返回第二个完成的TaskValidator的执行结果。
 * 4. 如果两个任务都抛出异常，那么invokeAny()将抛出ExecutionException异常。
 *
 * Created by hadoop on 2016/11/2.
 */
public class Main {
    public static void main(String[] args) {
        UserValidator validator1 = new UserValidator("LDAP");
        UserValidator validator2 = new UserValidator("DB");

        String username = "test";
        String password = "test";

        TaskValidator task1 = new TaskValidator(validator1, username, password);
        TaskValidator task2 = new TaskValidator(validator2, username, password);

        List tasks = new ArrayList();
        tasks.add(task1);
        tasks.add(task2);

        ExecutorService exerutor = Executors.newCachedThreadPool();
        try {
            String result = exerutor.invokeAny(tasks);

            System.out.printf("Main: Result: %s\n", result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        exerutor.shutdown();
        System.out.printf("Main: Eno of the execution\n");
    }
}

有一个验证成功。

Validator LDAP: validating a user during 7 seconds
Validator DB: validating a user during 7 seconds
DB: The username has been found
LDAP: The username has not been found
Main: Result: DB
Main: Eno of the execution

Process finished with exit code 0

都验证失败的结果。

Validator DB: validating a user during 7 seconds
Validator LDAP: validating a user during 3 seconds
LDAP: The username has not been found
DB: The username has not been found
Main: Eno of the execution
java.util.concurrent.ExecutionException: java.lang.Exception: Error validating user
    at java.util.concurrent.FutureTask.report(FutureTask.java:122)
    at java.util.concurrent.FutureTask.get(FutureTask.java:188)
    at java.util.concurrent.AbstractExecutorService.doInvokeAny(AbstractExecutorService.java:193)
    at java.util.concurrent.AbstractExecutorService.invokeAny(AbstractExecutorService.java:215)
    at cookbook.chapter_04.section_05.Main.main(Main.java:50)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
Caused by: java.lang.Exception: Error validating user
    at cookbook.chapter_04.section_05.TaskValidator.call(TaskValidator.java:24)
    at cookbook.chapter_04.section_05.TaskValidator.call(TaskValidator.java:8)
    at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:471)
    at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:745)