think async in java 8

2

Principal expert developer in T-System10 years in Java enterpriseBulgarian JUG co-leadConference [email protected]@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

Or…

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();

dalexandrov.net | @bercut2000 | jug.bg | @bgjugCasablanca | November 1-3, 2016 | @DevoxxMA

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.



https://en.wikipedia.org/wiki/Henry_Baker_(computer_scientist)

https://en.wikipedia.org/wiki/Henry_Baker_(computer_scientist)

https://en.wikipedia.org/wiki/Carl_Hewitt

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..


https://en.wikipedia.org/wiki/Daniel_P._Friedman

https://en.wikipedia.org/wiki/Futures_and_promises#cite_note-1

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()

get()

Result ready

main Thread 1


Future

Submit()

get()

Result ready

main Thread 1

Do something Useful here


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

block


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); }});

Guava

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<?>

CompletableFuture<T><<Interface>>

Future<T>

<<Interface>>

CompletionStage<T>

CompletableFuture<?>

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

Task2

Task3

Task8

Task9

Processor

Thread 2

Queue

Processor


Thread 1

Queue

Processor

Thread 2

Queue

ProcessorTask1

Task2

Task3

Task8

Task9


Thread 1

Queue

Processor

Thread 2

Queue

ProcessorTask1

Task2

Task3

Task8

Task9

Work stealing


Back to the CompletableFuture


Methods: create


Methods: create

• CompletableFuture() cf =new

CompletableFuture();


Methods: create

• CompletableFuture::supplyAsync(Supplier supplier)

• CompletableFuture::runAsync(Runnable runnable)

Methods: create• CompletableFuture::supplyAsync(Supplier 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

Step

Next step

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?


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)

Exceptions

Handle Exception

IOException


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

Throwable,T> fn)

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

• The exception is passed through the chainCasablanca | November 1-3, 2016 | @DevoxxMA dalexandrov.net | @bercut2000 | jug.bg |

@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();}

!Get()

“Prime”

Result ready

main Thread 1 Thread 2

Result ready

“Fibunacci”

Result ready

GET


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

GET


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



new• Remember the Observable Pattern?



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


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

handled elegantlyCasablanca | November 1-3, 2016 | @DevoxxMA dalexandrov.net | @bercut2000 | jug.bg |

@bgjug

Looks really nice• All benefits of async execution!



• Fits well to the reactive pattern!




• Comes out of the box!




• 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


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



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

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

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



think async in java 8

Software