What is new in java 8 concurrency

What is new in Java 8 Concurrency
T. Kishanthan
Technical Lead, WSO2
June 15, 2017

Agenda
● Java 8 - Lambda expressions, Streams
● Streams vs Parallel Streams
● Executor Framework
● Fork/Join Pool
● CompletableFuture
● ConcurrentHashMap Improvements
2

Java 8 Basics
Lambda
3
▪ A representation of an anonymous function which is passed
around.
▪ It doesn’t have a name, but has a list of parameters, a body, a
return type.

Java 8 Basics
Lambda
4
Before:
Comparator<Apple> byWeight = new Comparator<Apple>() {
public int compare(Apple a1, Apple a2) {
return a1.getWeight().compareTo(a2.getWeight());
}
};
After:
Comparator<Apple> byWeight =
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

Java 8 Basics
Lambda
5
Before:
Runnable r2 = new Runnable() {
@Override
public void run() {
System.out.println("Hello Java Colombo!");
}
};
After:
Runnable r1 = () -> System.out.println("Hello Java Colombo!");

Java 8 Basics
Streams
6
“A sequence of elements from a source that supports data
processing operations.”

Java 8 Basics
Streams
7
▪ Source - A data source such as collections, arrays, or I/O resources, where streams
consumes the elements.
▪ Sequence of elements - A stream provides a way to a get sequenced set of values of
a specific element type from a source. Collections are about data but streams are
about computations that applied on it.
▪ Data processing operations - Supports common set of operations like functional
programming languages to manipulate data, such as filter, map, reduce, find, sort,
etc. Operations can be executed either sequentially or in parallel.

Java 8 Basics
8
public static List<String> getLowCaloricDishesNamesInJava7(List<Dish> dishes) {
List<Dish> lowCaloricDishes = new ArrayList<>();
for (Dish d : dishes) {
if (d.getCalories() < 400) {
lowCaloricDishes.add(d);
}
}
List<String> lowCaloricDishesName = new ArrayList<>();
Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
public int compare(Dish d1, Dish d2) {
return Integer.compare(d1.getCalories(), d2.getCalories());
}
});
for (Dish d : lowCaloricDishes) {
lowCaloricDishesName.add(d.getName());
}
return lowCaloricDishesName;
}

Java 8 Basics
9
public static List<String> getLowCaloricDishesNamesInJava8(List<Dish> dishes) {
return dishes.stream()
.filter(d -> d.getCalories() < 400)
.sorted(comparing(Dish::getCalories))
.map(Dish::getName)
.collect(toList());
}

Java 8 Basics
Chaining stream operations forming a stream pipeline
10
Reference : Java 8 in Action - Lambdas, streams, and functional-style programming

Java 8 Basics
Chaining stream operations forming a stream pipeline
11
Demo

Streams vs Parallel Streams
▪ Parallel stream splits its data elements into multiple chunks, processing
each chunk with a different thread.
▪ Automatically partition the workload of a given operation on all the
cores of your multicore processor and keep all of them busy that
idling.

▪ Sequential version
public static long sequentialSum(long n) {
return Stream.iterate(1L, i -> i + 1)
.limit(n)
.reduce(Long::sum)
.get();
}

▪ Parallel version
public static long parallelSum(long n) {
return Stream.iterate(1L, i -> i + 1)
.limit(n)
.parallel()
.reduce(Long::sum)
.get();
}

Parallel Streams - Performance
Demo

Parallel Streams - Best Practices
▪ Automatic boxing and unboxing operations can dramatically hurt performance
▪ Some operations naturally perform worse on a parallel stream than on a
sequential stream
- findAny will perform better than findFirst - as no ordering is needed
▪ For small amount of data, using a parallel stream is not the correct choice
(almost)
▪ Parallel stream isn’t always faster than the corresponding sequential version and
can sometimes work in a counterintuitive way
- check their performance with an appropriate benchmark.

Executor Framework
▪ Introduced in Java 5 (ExecutorService) as a higher level replacement for
working with threads directly.
▪ Capable of running asynchronous tasks and allow to manage a pool of
threads rather than working with them directly.
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(() -> {
System.out.println("Hello " + threadName);
});

Executor Framework
Using Callable
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<Integer> future = executor.submit(() -> {
try {
TimeUnit.SECONDS.sleep(1);
return 777;
} catch (InterruptedException e) {
throw new IllegalStateException("Future was interrupted", e);
}
});
System.out.println("Is the future done ? : " + future.isDone());
Integer result = future.get();
System.out.println("Is the future done? : " + future.isDone());
System.out.println("Result : " + result);

Executor Framework
Multiple Callables
List<Callable<String>> callables = Arrays.asList(
() -> "Future Task 1",
() -> "Future Task 2",
() -> "Future Task 3");
executor.invokeAll(callables)
.stream()
.map(future -> {
try {
return future.get();
} catch (Exception e) {
throw new IllegalStateException(e);
}
})
.forEach(System.out::println);

Executor Framework
ScheduledExecutorService
ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
Runnable task = () -> System.out.println("Scheduling at: " + System.currentTimeMillis());
int initialDelay = 0;
int interval = 1;
executor.scheduleAtFixedRate(task, initialDelay, interval, TimeUnit.SECONDS);

Executor Framework
ScheduledExecutorService
ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
Runnable task = () -> {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("Scheduling at : " + System.currentTimeMillis());
} catch (InterruptedException e) {
System.err.println("Runnable task interrupted");
}
};
executor.scheduleWithFixedDelay(task, 0, 1, TimeUnit.SECONDS);

Fork/Join Pool
▪ Introduced in Java 7 (Java 8 features use it internally)
▪ Recursively split a parallelizable task into smaller tasks and then combine
the results of each subtask to produce the final result.
▪ pseudocode:
if (task is no longer divisible or small enough) {
sequentially compute the task
} else {
split task in two sub-tasks
recursively call this method to further split each task
wait for the completion of all subtasks
finally combine the results of each subtask
}

CompletableFuture
Future
▪ Models an asynchronous computation and provides a reference to its
result that will be available when the computation is completed.
▪ Invoking a potentially time-consuming operation inside a Future allows
the caller thread to return immediately and continue doing useful work
instead of getting blocked until the operation finishes.

Future vs CompletableFuture

Limitations with Future
▪ Combining two asynchronous computations in one, when they’re
independent and when the second depends on the result of the first
▪ Waiting for the completion of all tasks performed by a set of Futures
▪ Waiting for the completion of only the quickest task in a set of Futures
▪ Reacting to a Future completion (i.e, being notified when the
completion happens and then having the ability to perform a further
action using the result of the Future, instead of being blocked)

Requirement for CompletableFuture
▪ The fork/join framework and parallel streams are valuable tools for
parallelism; they split an operation into multiple sub-operations and
perform those sub-operations in parallel on different cores, CPUs.
▪ But don’t want to block the computations and waste precious clock
cycles of your CPU.

CompletableFuture
To demonstrate the CompletableFuture features, will be using a
best-price-finder application that contacts multiple online shops to find the
lowest price for a given product or service. This example is used in the
reference book - Java 8 in Action.
Following high level steps will be used to explain CompletableFuture
▪ How to provide an asynchronous API for your consumers
▪ How to make your code non-blocking when you’re a consumer of a
synchronous (blocking) API
▪ How to reactively process events representing the completion of an
asynchronous operation

CompletableFuture
sequentially querying all the shops
public List<String> findPricesSequential(String product) {
return shops.stream()
.map(shop -> shop.getPrice(product))
.collect(Collectors.toList());
}

CompletableFuture
parallely querying all the shops
public List<String> findPricesParallel(String product) {
return shops.parallelStream()
.collect(Collectors.toList());
}

CompletableFuture
List<CompletableFuture<String>> priceFutures = shops.stream()
.map(shop -> CompletableFuture.supplyAsync( () ->
String.format("%s price is %.2f", shop.getName(), shop.getPrice(product))))
.collect(toList());
priceFutures.stream()
.map(CompletableFuture::join)
.collect(toList());
supplyAsync : accepts a Supplier as argument and returns a CompletableFuture that will be
asynchronously completed with the value obtained by invoking that Supplier.

CompletableFuture
Pipelining asynchronous tasks
Adding another asynchronous task to the pipeline :
▪ Suppose that all the shops have agreed to use a centralized discount service.
▪ The discount service has an applyDiscount method returning the discounted
price for the product quote given.

CompletableFuture
Using the discount service
public List<String> findPricesSequential(String product) {
.map(Quote::parse)
.map(Discount::applyDiscount)
.collect(toList());
}

CompletableFuture
Composing synchronous and asynchronous operations
public Stream<CompletableFuture<String>> findPricesStream(String product) {
.map(shop -> CompletableFuture.supplyAsync(() -> shop.getPrice(product)))
.map(future -> future.thenApply(Quote::parse))
.map(future -> future.thenCompose(quote -> CompletableFuture.supplyAsync(() ->
Discount.applyDiscount(quote))));
}

CompletableFuture
▪ supplyAsync (Getting the prices) - query the shop asynchronously. The
result of this first transformation is a CompletableFuture which contains the
String returned by the corresponding shop.
▪ thenApply (Parsing the quotes) - convert those Strings into Quotes with a
second transformation. But because this parsing operation isn’t invoking any
remote service (no I/O in general), it can be invoked synchronously.

CompletableFuture
▪ thenCompose (Composing two different futures) - involves contacting the
remote Discount service to apply the appropriate discount percentage to the
non-discounted prices. This is executed remotely and for this reason we
want to perform it asynchronously - by creating another CompletableFuture
using supplyAsync method.
▪ thenCompose allows to pipeline two asynchronous operations, passing the
result of the first operation to the second operation when it becomes
available.

CompletableFuture
Demo

CompletableFuture
Reacting to a CompletableFuture completion
▪ thenAccept : specifies how to consume the result produced by the
CompletableFuture when it becomes available and returns a
CompletableFuture<Void>.
CompletableFuture[] futures = findPricesStream(product)
.map(f -> f.thenAccept(s -> System.out.println(s + " (done in " +
((System.nanoTime() - start) / 1_000_000) + " msecs)")))
.toArray(CompletableFuture[]::new);
CompletableFuture.allOf(futures).join();

CompletableFuture
Reacting to a CompletableFuture completion
Demo

CompletableFuture
Using custom executor
▪ The parallel stream version performs so well only because it can run 8 tasks
(8 core) in parallel, so it’s able to allocate exactly one thread for each shop.
▪ But what happens if you decide to add a 9th shop to the list of shops?

CompletableFuture
Using custom executor
Demo

ConcurrentHashMap Improvements
▪ With Java 8, ConcurrentHashMap has been enhanced with a set of
new methods to perform parallel operations effectively on it.
▪ forEach(): is capable of iterating over the key-value pairs of the map in
parallel.
▪ search(): returns a non-null search result for the current key-value pair
or null if the current iteration doesn't match the desired search criteria
passed as a BiFunction. (variants searchKeys, searchValues)
▪ reduce(): accepts two lambda expressions, first function transforms
each key-value pair into a single value of any type. The second function
combines all those transformed values into a single result - like map
and then reduce

● Other methods
○ putIfAbsent
○ getOrDefault
○ replaceAll
○ compute: with two variants computeIfAbsent() and
computeIfPresent()
○ forEachKey
○ forEachValue

Demo

References
● Java 8 in Action - Lambdas, streams, and functional-style programming by
Raoul-Gabriel Urma, Mario Fusco, and Alan Mycroft
○ Examples - https://github.com/java8/Java8InAction
● http://winterbe.com/posts/2015/04/07/java8-concurrency-tutorial-thread-executor-exam
ples/
○ Examples - https://github.com/winterbe/java8-tutorial
● Examples used in the session : https://github.com/Kishanthan/java8

What is new in java 8 concurrency

More Related Content

What's hot

Similar to What is new in java 8 concurrency

More from kshanth2101

Recently uploaded

What is new in java 8 concurrency