Java并发编程-18-在执行器中执行任务并处理结果

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

invokeAny()方法接受一个任务列表，然后运行任务，并返回第一个完成的任务并且没有抛出异常的任务的执行的结果

1、两个任务都返回true值：invokeAny()返回首先完成任务的名称

2、第一个任务返回true，第二个抛出异常，返回第一个任务执行的结果

3、第一个任务抛出异常，第二个返回true，返回第二个任务执行的结果

4、两个任务都抛出异常，那么invokeAny()将抛出异常

package com.concurrency.executor;

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

/**
 * 这个类模拟用户登陆验证
 * 
 * @author Nicholas
 *
 */
public class UserValidator {

	private String name;
	private String password;

	public String getName() {
		return name;
	}

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

	/**
	 * 模拟用户的登陆验证
	 * 
	 * @param name
	 * @param password
	 * @return
	 */
	public boolean Validate(String name, String password) {
		Random random = new Random();
		long duration = (long) (Math.random() * 10);
		System.out.printf("Validator %s:Validating a user during %d seconds\n",
				this.name, duration);
		try {
			// 等待一段随机时间模拟用户登陆
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e) {
			e.printStackTrace();
			return false;
		}

		// 返回随机bool值，返回true时，通过验证，false 没有通过验证
		return random.nextBoolean();
	}
}

package com.concurrency.executor;

import java.util.concurrent.Callable;

/**
 * 这个类将UserValidator对象作为并发任务来执行用户验证过程
 * 
 * @author Nicholas
 *
 */
public class TaskValidate implements Callable<String> {
	private UserValidator userValidator;

	private String userName;
	private String userPasswd;

	public TaskValidate(UserValidator userValidator, String userName,
			String userPasswd) {
		this.userValidator = userValidator;
		this.userName = userName;
		this.userPasswd = userPasswd;
	}

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

	public void testTaskValidate() {

		String username = "Nicholas";
		String password = "123456";

		//创建两个UserValidator对象
		UserValidator userValidator1 = new UserValidator("Adam");
		UserValidator userValidator2 = new UserValidator("Lorry");

		//创建两个TaskValidate对象，并且用UserValidator对象初始化
		TaskValidate taskValidate1 = new TaskValidate(userValidator1, username,
				password);
		TaskValidate taskValidate2 = new TaskValidate(userValidator2, username,
				password);
		
		//构建任务列表
		List<TaskValidate> tasklist = new ArrayList<TaskValidate>();
		tasklist.add(taskValidate1);
		tasklist.add(taskValidate2);

		//创建线程执行器
		ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) Executors
				.newCachedThreadPool();

		String result;

		try {
			//调用执行器的invokeAny()方法，使用任务列表作为参数
			result = threadPoolExecutor.invokeAny(tasklist);
			System.out.println("Main : Result :" + result);
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}

		threadPoolExecutor.shutdown();
		System.out.println("Main : End of the Execution...");

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

调用invokeAll()方法

package com.concurrency.executor;

/**
 * 这个一个结果类
 * @author Nicholas
 *
 */
public class Result {

	private String name;
	private int value;

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setValue(int value) {
		this.value = value;
	}

	public int getValue() {
		return value;
	}
}

package com.concurrency.executor;

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("Starting...." + this.name);

		try {
			// 等待一段随机时间
			long duration = (long) (Math.random() * 10);
			System.out.printf("%s : Waiting %d seconds for results.\n",
					this.name, duration);
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}

		int value = 0;
		for (int i = 0; i < 5; i++) {
			value += Math.random() * 100;
		}

		Result result = new Result();
		result.setName(name);
		result.setValue(value);
		return result;
	}
}

public void testTask() {
		ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) Executors
				.newCachedThreadPool();
		// 构建任务列表
		List<Task> listTasks = new ArrayList<Task>();
		for (int i = 0; i < 3; i++) {
			Task task = new Task(i + "");
			listTasks.add(task);
		}
		// 创建结果集
		List<Future<Result>> resultList = null;

		try {
			resultList = threadPoolExecutor.invokeAll(listTasks);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		threadPoolExecutor.shutdown();

		// 打印结果集
		System.out.println("Mian : Printing the results");
		for (int i = 0; i < resultList.size(); i++) {

			Future<Result> futureResult = resultList.get(i);

			try {
				Result result = futureResult.get();
				System.out
						.println(result.getName() + " : " + result.getValue());
			} catch (InterruptedException | ExecutionException e) {
				e.printStackTrace();
			}
		}
	}