think async in java 8

Think Asyncin Java 8

dalexandrov.net | @bercut2000 | jug.bg | @bgjug

Casablanca | November 1-3, 2016 | @DevoxxMA

Dmitry Alexandrov

Principal expert developer in T-System10 years in Java enterpriseBulgarian JUG co-leadConference co-org@bercut2000dmitry.aleksandrov@t-systems.com

Plan for today: rethink the way we use system resources

Let’s try to understand the word:

Asynchronous

Asynchronous• A form of computer control timing

protocol in which a specific operation begins after receiving a signal

Asynchronous• A form of computer control timing

protocol in which a specific operation begins after receiving a signal

• Not going at the same rate or exactly together with something else.

Asynchronous• In simple words:– Start the task somewhere else

Asynchronous• In simple words:– Start the task somewhere else– Notify me when its ready and I’ll process

the result

Asynchronous• In simple words:– Start the task somewhere else– Notify me when its ready and I’ll process

the result–… in terms of Java: start a new thread,

do something there, somehow get the result

Asynchronous• … by why?

Asynchronous• … by why?– It can be really faster

Asynchronous• … by why?– It can be really faster– Because its non-blocking

That class…• To get to the right understanding

That class…• To get to the right understanding• We need to have a look at it from

some different perspectives

That class…• To get to the right understanding• We need to have a look at it from

some different perspectives • Because several technologies

actually made it happen

But first: Evolution of

multithreading in Java

How it all began: Threads

public class HelloRunnable implements Runnable { public void run() { //get some value and store it a shared variable }

public static void main(String[] args) { (new Thread(new HelloRunnable())).start(); }}

How it all began: Threads

public class HelloThread extends Thread { public void run() { //get some value and store it a shared variable }

public static void main(String[] args) { (new HelloThread()).start(); }}

But then: Executor Services

And then Concurrency API has been introduced back in 2004 with the release of Java 5

But then: Executor Services

So that we no longer had to think at such a low level…

ExecutorService executorService = Executors.newFixedThreadPool(10);

executorService.execute(new Runnable() { public void run() { System.out.println("Asynchronous task"); }});

executorService.shutdown();

And with it came the…Future

Future – a primitive for creating multithreaded

applications

Actually that’s not something too new:

A somewhat similar concept future was introduced in 1977 in a paper by Henry Baker and Carl Hewitt.

a function:getASpecialInt()

We have to put this work (in a container)

Future

Putting work in a containerPromise

Promise• A function to put a work in a

“container”

Promise• A function to put a work in a

“container”

• This is not something new too..

The term promise was proposed in 1976 by Daniel P. Friedman and David Wise,[1] and Peter

Hibbard called it eventual..

FutureFuture:

- observe container and make callbacks- transform resulting value inside the

container

Conceptually we should NOT remove value outside of the container

Future

Future in Java

FutureReally hided lots of the intrinsic of the multithreading

ExecutorService executor = Executors.newFixedThreadPool(1);Future<Integer> future = executor.submit(task);

System.out.println("future done? " + future.isDone());

Integer result = future.get();

System.out.println("future done? " + future.isDone());System.out.print("result: " + result);

FutureThe interface was really simplistic:

• isDone()• Get() • Get(..timeout)

Are blocking..

So we are breaking the law!

Future

Submit()

Result ready

main Thread 1

Future

Submit()

Result ready

main Thread 1

Future

Submit()

Result ready

main Thread 1

Do something Useful here

From the definition:we don’t have to wait or

We have to make callbacks

CallbacksImagine:public static void processResultAsync(Supplier<List<Long>> supplier, ExecutorService executor, Consumer<List<Long>> onSuccess, Consumer<Throwable> onFail) { executor.submit(() -> { try { List<Long> lines = supplier.get(); onSuccess.accept(lines); } catch (Exception e) { onFail.accept(e); } });

CallbacksAnd now how we use it:final ExecutorService executor = Executors.newSingleThreadExecutor();

processResultAsync( AsyncCallbacks::getFibunacci, executor, System.out::println, Throwable::printStackTrace);

CallbacksBut the logic becomes really thick if get into callbacks:final ExecutorService executor = Executors.newSingleThreadExecutor();

processResultAsync( AsyncCallbacks::getPrime, executor, r -> processResultAsync( AsyncCallbacks::getFibunacci, executor, t-> System.out.println(r.stream() .filter(t::contains) .collect(Collectors.toList())), Throwable::printStackTrace ), Throwable::printStackTrace);

they did it elsewhere?• JavaScript/Node.js

they did it elsewhere?• JavaScript/Node.js• Non-blocking API, event driven model

they did it elsewhere?• JavaScript/Node.js• Non-blocking API, event driven model• Callbacks!

they did it elsewhere?• JavaScript/Node.js• Non-blocking API, event driven model• Callbacks! That’s so cool!

they did it elsewhere?• JavaScript/Node.js• Non-blocking API, event driven model• Callbacks! That’s so cool!• But in reality…

they did it elsewhere?

Say “callback” to a JavaScript developer and he will start

crying instantaneously!

Venkat Subramaniam

How they did it elsewhere

• JavaScript/Node.js• Non-blocking API, event driven model• Callbacks! That’s so cool!• But in reality… not cool!

• JavaScript/Node.js• Non-blocking API, event driven model• Callbacks! That’s so cool!• But in reality… not cool!• But promises kinda fixed that.

So instead of:

step1(function (value1) { step2(value1, function(value2) { step3(value2, function(value3) { step4(value3, function(value4) { // Do something with value4 }); }); });});

This look oh so much better:

Q.fcall(promisedStep1) .then(promisedStep2) .then(promisedStep3) .then(promisedStep4) .then(function (value4) {

// Do something with value4 }) .catch(function (error) {

// Handle any error from all above steps }) .done();

But not only in Javascript • Guava ListenableFuture addressed

the same issue

But not only in Javascript • Guava ListenableFuture addressed

the same issue

• But it was complicated..

GuavaListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUMBER_OF_THREADS));

ListenableFuture<String> listenableFuture = executor.submit(asyncTask);

Futures.addCallback(listenableFuture, new FutureCallback<String>() { public void onSuccess(String result) { doMoreWithTheResultImmediately(result); }

public void onFailure(Throwable thrown) { handleFailure(thrown); }});

Futures.transform()…

Let’s now put it all together!

How to achieve asynchronicity in Java 8

*without additional libraries

It’s done by:CompletableFuture<T>

CompletableFuture<T>• Core library since Java 8

CompletableFuture<T><<Interface>>

Future<T>

CompletableFuture<?>

Future<T>

<<Interface>>

CompletionStage<T>

Future<T>

<<Interface>>

CompletionStage<T>

CompletableFuture<T>• Core library since Java 8• Implements Future<T>• Implements CompletionStage<T>

– Composition element– Function resolution– Link through results– Transformation methods– toCompletableFuture()

• Async operations

Foundation

1. Lambdas & Method ref.

• No more explicit Callables or Runnables

• No more ugly anonymous classes

• Just use Lambdas and Method references

2. ForkJoinThe ForkJoinPool (since JDK7) is an ideal helper for async programs

• Cares for cache corruption• Knows better when and where a task should run• Optimized for tasks creating new tasks• Avoid changing threads until workload is significant

Thread 1

QueueTask1

Processor

Thread 2

Processor

Thread 1

Processor

Thread 2

ProcessorTask1

Thread 1

Processor

Thread 2

ProcessorTask1

Work stealing

Back to the CompletableFuture

Methods: create

• CompletableFuture() cf =new

CompletableFuture();

Methods: create

• CompletableFuture::supplyAsync(Supplier supplier)

• CompletableFuture::runAsync(Runnable runnable)

Methods: create• CompletableFuture::supplyAsync(Supplier<U

> supplier[, Executor executor])

• CompletableFuture::runAsync(Runnable runnable[, Executor executor])

• ForkJoin.commonPool() by default

Methods: terminal

Methods: completeUnlike the Future<?>:

• CompletableFuture()::– complete(T value)– completeExceptionally(Throwable e)

Methods: terminal• Can be completed only once!

• Can be run async but does not exclude blocking!

Methods: terminal• CompletableFuture<Void>::thenAccept(Consumer

<T> c)

• CompletableFuture<Void>::thenRun(Runnable action)

• Async versions

Methods: transform

Remember this?

Methods: transform• CompletableFuture::thenApply(Function<T,U

> fn)– Done in the same thread

• CompletableFuture::thenApplyAsync(Function<T,U> fn, [Executor executor])

So if we get back to asyncWe just get the Prime method as it is:

public static List<Long> getPrimes() { List<Long> found = new ArrayList<Long>(); …. return found;}

So if we get back to asyncAnd just write one single line:

CompletableFuture.supplyAsync(AsyncCallbacks::getPrime) .thenAccept(System.out::println);

Lets dive deeper

Composition

CF<T> CF

Transform smart

CompositionBut if we want both Futures to be completed in sequence:

• CompletableFuture:: thenCompose(Function<T,CompletableFuture> fn)

• CompletableFuture:: thenComposeAsync(Function<T,CompletableFuture> fn)

CompositionBut if we want both Futures to be completed in sequence :

.. to avoid: CompletableFuture<CompletableFuture<T>>

CompositionBut if we want both Futures to be completed:

.. to avoid: CompletableFuture<CompletableFuture<T>>

.. just like flatMap

And we getCompletableFuture<String> FilesUtils.readFileAsync(Path path)

CompletableFuture.supplyAsync(FilesUtils.readFileAsync(“…”)) .thenComposeAsync(content->processContent(content)) .thenAccept(System.out::println);

Combine/Reduce

Next step

CombinationSo if the previous step returns Future<T>:

• CompletableFuture<V>:: thenCombine(CompletionStage other, BiFunction<T,U,V> fn)

• CompletableFuture<V>:: thenCombineAsync(CompletionStage other, BiFunction<T,U,V> fn)

Combination• Just imagine how that would be with just Futures:

Future<List<Integer>> primesFuture = getPrimes();Future<List<Integer>> fibunacciFuture = getFibunacci();

...List<Integer> primes = primesFuture.get();List<Integer> fibunaccis= fibunacciFuture.get();// intersect

Combine/ReduceAnd we don’t want further processing:

• CompletableFuture<Void>:: thenAcceptBoth(CompletableFuture other, BiConsumer<T,U> block)

• CompletableFuture<Void>::runAfterBoth(CompletableFuture<?> other, Runnable action)

Combine/ReduceOr we want just the first available result:

• CompletableFuture<Void>:: acceptEither(CompletableFuture<T> other, Consumer<T> block)

• CompletableFuture<Void>:: runAfterEither(CompletableFuture<?> other, Runnable action)

• But what happens to the second one?

• So handle with care!

@bgjug

• So handle with care!

@bgjug

Combine/Reduce• CompletableFuture::

applyToEither(CompletableFuture<? extends T> other, Function<? super T,U> fn)

Multiple futures• CompletableFuture<Void>

allOf(CompletableFuture<?>... cfs)

• CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

Multiple futures• CompletableFuture<Void>

allOf(CompletableFuture<?>... cfs)

• CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

Exceptions

Handle Exception

IOException

Exceptions• CompletableFuture<T>::exceptionally(Function<

Throwable,T> fn)

• CompletableFuture<Void>::handle(BiFunction<T,Throwable,U> fn)

@bgjug

ExceptionsLooks really safe:

CompletableFuture<Integer> safe = future.handle((val, ex) -> { if (val != null) { return Long.valueOf(val); } else { log.warn("Huston, we a have problem!", ex); return -1; }});

Exceptions

CompletableFuture.supplyAsync(FilesUtils.readFileAsync(“…”)) .thenComposeAsync(content->processContent(content)) .thenAccept(System.out::println) .exceptionally(Throwable::printStackTrace);

The API• You have probably noticed

The API• You have probably noticed • Unlike the Future<T>

The API• You have probably noticed • Unlike the Future<T>• The API is really BIG

The API• You have probably noticed • Unlike the Future<T>• The API is really BIG• Mostly fits the pattern:

<function>[Async](param,[Executer])

The API• You have probably noticed • Unlike the Future<T>• The API is really BIG• Mostly fits the pattern:

<function>[Async](param,[Executer])

>60 methods!!!

CF for async• Organize the work as a chain/flow of events/tasks– Do this then that (chaining)– Do this and/or that (joining)– Do this on failure (recovering)

CF for async• When we program asynchronously we usually

think in terms of workflows, events and tasksQuery

“Primes”

Query “Fibs”

Gather perf data

Gather statistics

Return response

Log data

Handle Exception

We have some (not so) bad heredity…

Get• T get() throws InterruptedException, ExecutionException

• T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException

• T getNow(T valueIfAbcent)

• T join() throws CancellationException, CompletionException

Get• T get() throws InterruptedException, ExecutionException

• T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException

• T getNow(T valueIfAbcent)

• T join() throws CancellationException, CompletionException

• T obtrudeValue() never ever use that!!!

So have in mind:Imagine:

@GET@Path("intersection")public String getIntersection() throws ExecutionException, InterruptedException { CompletableFuture<List<Long>> fib = new FibunacciFuture().getFibunacci(50L); CompletableFuture<List<Long>> primes = new PrimeFuture().getPrime(10000L); CompletableFuture<List<Long>> intersection = fib.thenCombineAsync(primes, (a, b) ->

a.stream() .filter(b::contains) .collect(Collectors.toList())); return intersection.thenApply(List::toString).get();}

So have in mind:Imagine:

@GET@Path("intersection")public String getIntersection() throws ExecutionException, InterruptedException { CompletableFuture<List<Long>> fib = new FibunacciFuture().getFibunacci(50L); CompletableFuture<List<Long>> primes = new PrimeFuture().getPrime(10000L); CompletableFuture<List<Long>> intersection = fib.thenCombineAsync(primes, (a, b) ->

a.stream() .filter(b::contains) .collect(Collectors.toList())); return intersection.thenApply(List::toString).get();}

!Get()

“Prime”

Result ready

main Thread 1 Thread 2

Result ready

“Fibunacci”

Result ready

Should be supported all over

@GET@Path("intersectionAsync")public void getIntersectionAsync(@Suspended AsyncResponse response) { CompletableFuture<List<Long>> fib = new FibunacciFuture().getFibunacci(50L); CompletableFuture<List<Long>> primes = new PrimeFuture().getPrime(10000L); CompletableFuture<List<Long>> intersection = fib.thenCombineAsync(primes, (a, b) -> a.stream() .filter(b::contains) .collect(Collectors.toList()));

intersection.thenApplyAsync(List::toString).thenApplyAsync(response::resume).exceptionally(e->response.resume(e.getLocalizedMessage()));

response.setTimeout(10, TimeUnit.SECONDS); response.setTimeoutHandler(e->response.resume(new TimeoutException()));}

Async everywhere

“Prime”

Result ready

main Thread 1 Thread 2

Result ready

“Fibunacci”

Both results ready

REACTIVE

REACTIVE is the new CLOUD

If you program reactively:

• You are the master of the Universe• Your salary doubles every time you

say this word• You are the star of the Java geek

parties

If you program reactively:

• You are the master of the Universe• Your salary doubles every time you

say this word• You are the star of the Java geek

parties• … until serverless came out

But lets be honest• Actually, there is nothing so much

new• Remember the Observable Pattern?

new• Remember the Observable Pattern?• The key word is Asynchronous

new• Remember the Observable Pattern?• The key word is Asynchronous• Java 8 supports now the pattern

@bgjug

And of course…

Reactive

And what a good Reactive is

• Avoid blocking threads– Optimize the CPU usage

• Avoid changing threads– Optimize cache usage

• Avoid crippling failures– Failure of one task should be isolated and

@bgjug

Looks really nice• All benefits of async execution!

• Fits well to the reactive pattern!

• Comes out of the box!

• Handle with care)

That’s all folks!

Any questions?

Thank you!Merci beaucoup!

Some more to read• http://

www.nurkiewicz.com/2013/05/java-8-definitive-guide-to.html

• https://habrahabr.ru/post/213319/

• https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html

think async in java 8

Software

async python

think java: java programming language part 2 chia james...

mastering async with ratpack - github pages ›...

async enhancement

async/sync and sync/async bridge...

falling in love with async await in love with async...

async webapps -...

async programming with async task

java programming in reactive -...

async, await

think with java

think java: java programming language part 1

async javascript

async/sync and sync/async bridge scenarios · async/sync...

training – going async

async with c#...

{ async patterns }

002-2 think in java 4 answer

java implementation of channel access (caj) - · 500 1000...

play framework: async i/o with java and scala