Parallel and Asynchronous Programming with Java 8

How Java 8 changes style of coding

package com.company;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        List<Integer> integerList = IntStream
                .range(1,100)
                .boxed()
                .collect(Collectors.toList());

        //imperative Style of coding
        int sum = 0;
        for (Integer integer:integerList){
                sum = sum+(integer*2);
        }
        System.out.println(sum);

        //Declarative Style of coding
        Integer sumValue =integerList
                .stream()
                .mapToInt(e->e*2).sum();

        System.out.println(sumValue);
    }
}

The Past

The Structure of concurrent code was very different from the structure of sequential code.

The Present

The Structure of concurrent code is same as the structure of sequential code.

Making the previous code concurrent

package com.company;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

    static Integer transform(Integer e){
        System.out.println("Current Thread :: "+Thread.currentThread());
        return e*2;
    }

    public static void main(String[] args) {

        List<Integer> integerList = IntStream
                .range(1,10)
                .boxed()
                .collect(Collectors.toList());
        
        Integer sumValue =integerList
                .parallelStream()
                .mapToInt(Main::transform).sum();


        System.out.println(sumValue);
    }
}

If you are source of the stream then use parallelStream If you are not the source of the stream then use parallel.

We can also make parallel streams on the basis of certain conditions

Convert a parallel stream to sequential Stream

package com.company;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static Integer transform(Integer e){
        System.out.println("Current Thread :: "+Thread.currentThread());
        return e*2;
    }

    static Stream<Integer> getStream(){
        List<Integer> integerList = IntStream
                .range(1,10)
                .boxed()
                .collect(Collectors.toList());

        return integerList.parallelStream();
    }

    public static void main(String[] args) {

        Integer sumValue = getStream()
                .sequential()
                .mapToInt(Main::transform).sum();

        System.out.println(sumValue);
    }
}

Preserve Order in Map Operation

package com.company;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static Integer transform(Integer e){
        System.out.println("Current Thread :: "+Thread.currentThread());
        return e;
    }

    static Stream<Integer> getStream(){
        List<Integer> integerList = IntStream
                .range(1,10)
                .boxed()
                .collect(Collectors.toList());

        return integerList.parallelStream();
    }

    public static void main(String[] args) {
         getStream()
                .mapToInt(Main::transform)
                .forEachOrdered(System.out::println);
    }
}

Preserve Order in Filter

package com.company;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static Integer transform(Integer e){
        System.out.println("Current Thread :: "+Thread.currentThread());
        return e;
    }

    static boolean filterElements(Integer e){
        return e%2==0;
    }

    static Stream<Integer> getStream(){
        List<Integer> integerList = IntStream
                .range(1,10)
                .boxed()
                .collect(Collectors.toList());

        return integerList.parallelStream();
    }

    public static void main(String[] args) {
         getStream()
                .filter(Main::filterElements)
                .forEachOrdered(System.out::println);
    }
}

Reduce with Parallel Streams

We have to be really careful while working with reduce in parallel stream. The initial value of the stream should be identity.

package com.company;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static Integer reduceElements(int a,int b){
        return a+b;
    }

    static Stream<Integer> getStream(){
        List<Integer> integerList = IntStream
                .range(1,10)
                .boxed()
                .collect(Collectors.toList());
        return integerList.stream();
    }

    public static void main(String[] args) {
        System.out.println(
        getStream()
                .parallel()
                .reduce(0,Main::reduceElements)
        );
    }
}

Following code will work fine with parallel stream because for addition 0 value is identity

Following code will not work correctly with parallel stream because for addition 12 value is not identity

package com.company;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static Integer reduceElements(int a,int b){
        return a+b;
    }

    static Stream<Integer> getStream(){
        List<Integer> integerList = IntStream
                .range(1,10)
                .boxed()
                .collect(Collectors.toList());
        return integerList.stream();
    }

    public static void main(String[] args) {
        System.out.println(
        getStream()
                .parallel()
                .reduce(12,Main::reduceElements)
        );
    }
}

Order is preserved by default in findFirst

package com.company;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static boolean filterElements(Integer e){
        return e%2==0;
    }

    static Stream<Integer> getStream(){
        List<Integer> integerList = IntStream
                .range(1,100)
                .boxed()
                .collect(Collectors.toList());
        return integerList.stream();
    }

    public static void main(String[] args) {
        System.out.println(
        getStream()
                .parallel()
                .filter(Main::filterElements)
                .findFirst()
        );
    }
}

Proof of efficiency of parallel stream

package com.company;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static Integer mapElements(Integer e)  {
        try {
            Thread.sleep(500);

        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("Current Thread>>"+Thread.currentThread());
        return e*2;
    }

    static Stream<Integer> getStream(){
        List<Integer> integerList = IntStream
                .range(1,10)
                .boxed()
                .collect(Collectors.toList());
        return integerList.stream();
    }

    public static void main(String[] args) {
        Long startTime= System.currentTimeMillis();
        System.out.println(
        getStream()
                .parallel()
                .map(Main::mapElements)
                .reduce(0,(a,b)-> a+b)
        );

        Long endTime= System.currentTimeMillis();

        System.out.println("Time taken "+(endTime-startTime));
    }
}

For computational Intensive

How many Threads should I create?

Number of threads you should create should be less then or equal to number of cores in CPU.

For IO Intensive

Number of threads <= number of cores / 1-blocking factor

0 < blocking factor < 1

Common Pool contains Pool of threads One less than total cores

Number of cores in your system

Runtime.getRuntime().availableProcessors();

 ForkJoinPool forkJoinPool= ForkJoinPool.commonPool();
 System.out.println(forkJoinPool);

Default Fork and Join Pool for Multi Threading

Configuring Threads Programatically

package com.company;

import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static Integer mapElements(Integer e)  {
        try {
            Thread.sleep(50);

        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("Current Thread>>"+Thread.currentThread());
        return e*2;
    }

    static Stream<Integer> getStream(){
        List<Integer> integerList = IntStream
                .range(1,100)
                .boxed()
                .collect(Collectors.toList());
        return integerList.stream();
    }

    public static void main(String[] args) throws InterruptedException {


        Long startTime= System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool(8);
        forkJoinPool.submit(()->{
            System.out.println( getStream()
                    .map(Main::mapElements)
                    .reduce(0,(a,b)-> a+b));
        });
        forkJoinPool.shutdown();
        forkJoinPool.awaitTermination(30, TimeUnit.SECONDS);
        Long endTime= System.currentTimeMillis();
        System.out.println("Time taken "+(endTime-startTime));
    }
}

Lazy Evaluation in stream

It does not execute on a function on a collection of data.

It instead executes a collection on function on a piece of data

package com.company;

import java.util.Arrays;
import java.util.List;

public class Main {

   static List<Employee> getData(){
      return  Arrays.asList(
                new Employee("emp1",23,"mumbai"),
                new Employee("emp2",32,"delhi"),
                new Employee("emp3",35,"delhi"),
                new Employee("emp4",47,"mumbai"),
                new Employee("emp5",37,"delhi"),
                new Employee("emp6",52,"delhi")
                );
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println(
                getData()
                        .stream()
                        .parallel()
                        .filter(e->{
                                    System.out.println(e.getName());
                            return  e.getAge()>33;
                        }
                            )
                        .filter(e->e.getCity().equals("delhi"))
                        .findFirst()
        );
    }
}

package com.company;

class Employee {

    private String name;
    private Integer age;
    private String city;

    public Employee(String name, Integer age, String city) {
        this.name = name;
        this.age = age;
        this.city = city;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", city='" + city + '\'' +
                '}';
    }
}

Exercise 1

Create a Stream of Integers and apply a map operation on it.
Now make the stream parallel and check its efficiency by using sleep.
Try to convert a parallel stream to sequential stream.
Preserve the Order in Map and Filter Operation.
Perform a reduce operation with and without identity value.
Configure Threads Programatically for a parallel operation.
Try Lazy evaluation with findFirst and try it with parallel

Old way of running Thread

new Thread(()-> System.out.println("Running Thread"))
                .start();

CompletableFuture.runAsync(()->{
            System.out.println("Running Thread");
        });

New Way of running thread

Running Thread with completion Callback

CompletableFuture
               .runAsync(()-> System.out.println("Running Thread"))
               .thenRun(()-> System.out.println("Complete Callback"));

Returning value from thread

CompletableFuture.supplyAsync(()->{
            System.out.println("Returning value from thread");
            return 2;
        });

Using the value returned from a thread

CompletableFuture.supplyAsync(()->{
            System.out.println("Returning value from thread");
            return 2;
        }).thenAccept(System.out::println);

Transforming the value from Thread

CompletableFuture.supplyAsync(()->{
            System.out.println("Returning value from thread");
            return 2;
        })
                .thenApply(e->e*2)
                .thenAccept(System.out::println);

Performing Async Operations

CompletableFuture.supplyAsync(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Returning value from thread");
            return 2;
        })
                .thenApplyAsync(e->{
                        try {
                        Thread.sleep(1000);
                        } catch (InterruptedException ex) {
                        ex.printStackTrace();
                        }
                      return  e*2;}
                )
                .thenAcceptAsync(System.out::println);

        Thread.sleep(3000);

Find out success and failure of callback

CompletableFuture.supplyAsync(()->{
            System.out.println("Returning value from thread");
            throw  new RuntimeException();
        }).whenCompleteAsync((a,b)->{
            if(b!=null){
                System.out.println("Exception");
                System.out.println(b.getMessage());
            }else{
                System.out.println("Success");
            }
        });

package com.company;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Main {

    static int performSomeOperation(){
        return 5;
    }

   static void delegatingCompletableFuture(CompletableFuture<Integer> completableFuture){

        completableFuture.complete(performSomeOperation());
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        CompletableFuture<Integer> completableFuture= new CompletableFuture<>();
        completableFuture
                .thenApplyAsync(e->e*2)
                .thenAcceptAsync(System.out::println);

        delegatingCompletableFuture(completableFuture);

        Thread.sleep(1000);

    }
}

Delegating CompletableFuture

Find out later in the program whether task is completed or cancelled

package com.company;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Main {

    static int performSomeOperation(){
        return 4;
    }

   static void delegatingCompletableFuture(CompletableFuture<Integer> completableFuture){

        int number = performSomeOperation();
        if(number%2==0) {
            completableFuture.complete(performSomeOperation());
        }else{
            completableFuture.cancel(true);
        }
       
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        CompletableFuture<Integer> completableFuture= new CompletableFuture<>();
        completableFuture
                .thenApplyAsync(e->e*2)
                .thenAcceptAsync(System.out::println);

        delegatingCompletableFuture(completableFuture);

        Thread.sleep(1000);

       if(completableFuture.isDone()){
           System.out.println("Task Completed");
       }

       if(completableFuture.isCancelled()){
           System.out.println("Task has been canceled");
       }
    }
}

Composing more than one Completable Futures together

CompletableFuture.supplyAsync(()-> 1)
                .thenCompose((e)-> CompletableFuture.supplyAsync(()->e+3 ))
                .thenCompose((e)-> CompletableFuture.supplyAsync(()->e+5 ))
                .thenAcceptAsync(System.out::println);

Combining Independent Completable Future

 CompletableFuture.supplyAsync(()->1).
                thenCombine(CompletableFuture.supplyAsync(()->2), (a,b)-> a+b ).
                thenAcceptAsync(System.out::println);

package com.company;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Main {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        boolean runException = true;

        CompletableFuture.supplyAsync(()->{
            if(runException) {
                throw new RuntimeException("Something went wrong");
            }
           return  1;
        })
                .exceptionally(th-> {
                    System.out.println(th);
                    // throw new RuntimeException("Something went wrong again");
                    return 2;
                })
                
                .thenApplyAsync(e->e*2)

                .exceptionally(th-> {
                    System.out.println(th);
                    throw new RuntimeException();
                })

                .thenAcceptAsync(System.out::println);

    }
}

Recovering from error

Exercise 2

Run a Thread using Completable Future
Run a callback after completion of the thread execution
Return result on completion of a thread, transform the result using asyncApply and use the result using asyncAccept
Find out the success and failure of a callback
Delegate the Completablefuture to some other method
After delegating future find out whether the task has been completed or not.
Try Composing and Combining twoCompletableFuture together
Throw an error in CompletableFuture and then try to recover from it.