Java Concurrency

Running multiple tasks and processing the first result

A common problem in concurrent programming is when you have various concurrent tasks that solve a problem, and you are only interested in the first result of those tasks. For example, you want to sort an array. You have various sort algorithms. You can launch all of them and get the result of the first one that sorts these, that is, the fastest sorting algorithm for a given array.

In this case, you are going to implement an example where a user can be validated by two mechanisms. The user will be validated if one of those mechanisms validates it.

/**
 * This class implement a simulation of a user validation system. It suspend the Thread
 * a random period of time and then returns a random boolean value. We consider that it
 * returns the true value when the user is validated and the false value when it's not
 */
public class UserValidator {
    
    /**
     * The name of the validation system
     */
    private String name;
    
    public UserValidator(String name) {
        this.name=name;
    }
    
    /**
     * Method that validates a user
     * @param name Name of the user
     * @param password Password of the user
     * @return true if the user is validated and false if not
     */
    public boolean validate(String name, String password) {
        // Create a new Random objects generator
        Random random=new Random();
        
        // Sleep the thread during a random period of time
        try {
            Long duration=(long)(Math.random()*5);
            System.out.printf("Validator %s: Validating a user during %d seconds
",this.name,duration);
            TimeUnit.SECONDS.sleep(duration);
        } catch (InterruptedException e) {
            return false;
        }
        
        // Return a random boolean value
        return random.nextBoolean();
    }
    
    /**
     * Return the name of the validation system
     * @return The name of the validation system
     */
    public String getName(){
        return name;
    }

}


/**
 * This class encapsulate a user validation system to be executed as a Callable object.
 * If the user is validated, it returns the name of the validation system. If not,
 * it throws an Exception
 */
public class TaskValidator implements Callable<String> {

    /**
     * The user validator used to validate the user.
     */
    private UserValidator validator;
    /**
     * The name of the user
     */
    private String user;
    /**
     * The password of the user
     */
    private String password;
    
    /**
     * Constructor of the class
     * @param validator The user validator system used to validate it 
     * @param user The name of the user
     * @param password The password of the user
     */
    public TaskValidator(UserValidator validator, String user, String password){
        this.validator=validator;
        this.user=user;
        this.password=password;
    }
    
    /**
     * Core method of the Callable interface. Tries to validate the user using the user
     * validation system. If the user is validated, returns the name of the validation system. 
     * If not, throws and Exception
     * @return The name of the user validation system.
     * @throws Exception An exception when the user is not validated
     */
    @Override
    public String call() throws Exception {
        if (!validator.validate(user, password)) {
            System.out.printf("%s: The user has not been found
",validator.getName());
            throw new Exception("Error validating user");
        }
        System.out.printf("%s: The user has been found
",validator.getName());
        return validator.getName();
    }

}


/**
 * This is the main class of the example. Creates two user validation systems and execute
 * them in an Executor using the invokeAny() method. If the user is validated by one of the
 * user validation systems, then it shows a message. If both system don't validate the user,
 * the application processes the ExecutionException thrown by the method
 */
public class Main {
    
    public static void main(String[] args) {

        // Initialize the parameters of the user
        String username = "test";
        String password = "test";

        // Create two user validation objects
        UserValidator ldapValidator = new UserValidator("LDAP");
        UserValidator dbValidator = new UserValidator("DataBase");

        // Create two tasks for the user validation objects
        TaskValidator ldapTask = new TaskValidator(ldapValidator, username, password);
        TaskValidator dbTask = new TaskValidator(dbValidator, username, password);

        // Add the two tasks to a list of tasks
        List<TaskValidator> taskList = new ArrayList<>();
        taskList.add(ldapTask);
        taskList.add(dbTask);
        
        // Create a new Executor
        ExecutorService executor = (ExecutorService) Executors.newCachedThreadPool();
        String result;
        try {
            // Send the list of tasks to the executor and waits for the result of the first task 
            // that finish without throw any Exception. If all the tasks throw an Exception, the
            // method throws an ExecutionException.
            result = executor.invokeAny(taskList);
            System.out.printf("Main: Result: %s
",result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        
        // Shutdown the Executor
        executor.shutdown();
        System.out.printf("Main: End of the Execution
");
    }

}

The key of the example is in the Main class. The invokeAny() method of the ThreadPoolExecutor class receives a list of tasks, launches them, and returns the result of the first task that finishes without throwing an exception. This method returns the same data type that the call() method of the tasks you launch returns. In this case, it returns a String value.

The following screenshot shows the output of an execution of the example when one task validates the user:

The example has two UserValidator objects that return a random boolean value. Each UserValidator object is used by a Callable object, implemented by the TaskValidator class. If the validate() method of the UserValidator class returns a false value, the TaskValidator class throws Exception. Otherwise, it returns the true value.

So, we have two tasks that can return the true value or throw an Exception exception. You can have the following four possibilities:

• Both tasks return the true value. The result of the invokeAny() method is the name of the task that finishes in the first place.
• The first task returns the true value and the second one throws Exception. The result of the invokeAny() method is the name of the first task.
• The first task throws Exception and the second one returns the true value. The result of the invokeAny() method is the name of the second task.
• Both tasks throw Exception. In that class, the invokeAny() method throws an ExecutionException exception.

If you run the examples several times, you get the four possible solutions you can get.

The following screenshot shows the output of the application when both tasks throw an exception:

The ThreadPoolExecutor class provides another version of the invokeAny() method:

invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit): This method executes all the tasks and returns the result of the first one that finishes without throwing an exception, if it finishes before the given timeout passes. The TimeUnit class is an enumeration with the following constants: DAYS, HOURS, MICROSECONDS, MILLISECONDS, MINUTES, NANOSECONDS, and SECONDS.

Running multiple tasks and processing all the results

The Executor framework allows you to execute concurrent tasks without worrying about thread creation and execution. It provides you the Future class that you can use to control the status and get the results of any task executed in an executor.

When you want to wait for the finalization of a task, you can use the following two methods:

• The isDone() method of the Future interface returns true if the task has finished its execution.
• The awaitTermination() method of the ThreadPoolExecutor class puts the thread to sleep until all the tasks have finished their execution after a call to the shutdown() method.

These two methods have some drawbacks. With the first one, you can only control the completion of a task, and with the second one, you have to shutdown the executor to wait for a thread, otherwise the method's call returns immediately.

The ThreadPoolExecutor class provides a method that allows you to send to the executor a list of tasks and wait for the finalization of all the tasks in the list.

In this case, you will learn how to use this feature by implementing an example with three tasks executed and their results printed out when they finish.

/**
 * This class stores the result generated by one task
 *
 */
public class Result {

    private int num;
    private long factorial;
    
    public Result(int num, long factorial) {
        super();
        this.num = num;
        this.factorial = factorial;
    }
    
    public int getNum() {
        return num;
    }
    
    public long getFactorial() {
        return factorial;
    }
}


/**
 * This class calculates the factorial of a number.
 */
public class FactorialCalculator implements Callable<Result> {
    
    /**
     * Number to calculate the factorial
     */
    private int num;
    
    /**
     * Constructor of the class. Initializes the attributes
     * @param num Number to calculate the factorial
     */
    public FactorialCalculator(int num) {
        this.num = num;
    }

    /**
     * Method called by the executor to execute this task and calculate the factorial of a number
     */
    @Override
    public Result call() throws Exception {
        TimeUnit.SECONDS.sleep(new Random().nextInt(3));
        if (num < 0) {
            throw new IllegalArgumentException("The number must be less than zero.");
        }
        if (num <= 1) {
            return new Result(num, 1L);
        }
        long f = 1;
        for (int i = 2; i <= num; i++) {
            f *= num;
        }
        return new Result(num, f);
    }

}


/**
 * Main class of the example. Launch three tasks using the invokeAll() method
 * and then prints their results to the console
 */
public class Main {

    public static void main(String[] args) {
        
        // Create three tasks and stores them in a List
        List<Callable<Result>> taskList = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Callable<Result> factorialTask = new FactorialCalculator(new Random().nextInt(10));
            taskList.add(factorialTask);
        }

        // Create an executor
        ExecutorService executor = (ExecutorService) Executors.newCachedThreadPool();
        
        // Call the invokeAll() method
        List<Future<Result>> resultList = new ArrayList<>();
        try {
            resultList = executor.invokeAll(taskList);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // Finish the executor
        executor.shutdown();
        
        // Writes the results to the console
        for (int i = 0; i < resultList.size(); i++) {
            try {
                Result result = resultList.get(i).get();
                System.out.printf("%d! = %d
", result.getNum(), result.getFactorial());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

}

In this case, you have learned how to send a list of tasks to an executor and wait for the finalization of all of them using the invokeAll() method. This method receives a list of the Callable objects and returns a list of the Future objects. This list will have a Future object per task in the list. The first object in the list of the Future objects will be the object that controls the first task in the list of the Callable objects, and so on.

The first point to take into consideration is that the type of data used for the parameterization of the Future interface in the declaration of the list that stores the result objects must be compatible with the one used to parameterized the Callable objects. In this case, you have used the same type of data: the Result class.

Another important point about the invokeAll() method is that you will use the Future objects only to get the results of the tasks. As the method finishes when all the tasks have finished, if you call the isDone() method of the Future objects that is returned, all the calls will return the true value.

The ExecutorService class provides another version of the invokeAll() method:

• invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit): This method executes all the tasks and returns the result of their execution when all of them have finished, if they finish before the given timeout passes. The TimeUnit class is an enumeration with the following constants: DAYS, HOURS, MICROSECONDS, MILLISECONDS, MINUTES, NANOSECONDS, and SECONDS.