Flavors of Concurrency in Java

Oleg Šelajev
@shelajev
ZeroTurnaround
Flavors of Concurrency in Java

WHY DO WE CARE?
https://twitter.com/reubenbond/status/662061791497744384

CONCURRENCY | PARALLELISM
http://joearms.github.io/2013/04/05/concurrent-and-parallel-programming.html

CONCURRENCY
Shared resources
Multiple consumers & producers
Out of order events
Locks & Deadlocks

THREADS
ORGANIZED THREADS
FORK-JOIN FRAMEWORK
COMPLETABLE FUTURES ACTORS FIBERS
SOFTWARE TRANSACTIONAL MEMORY

HOW TO MANAGE CONCURRENCY?
http://zeroturnaround.com/rebellabs/ﬂavors-of-concurrency-in-java-threads-executors-forkjoin-and-actors/

PROBLEM
private static String
getFirstResult(String question,
List<String> engines)
{
// HERE BE DRAGONS, PARALLEL DRAGONS
return null;
}

WHY THREADS
Model Hardware
Processes
Threads

THREADS
private static String getFirstResult(String question,
List<String> engines) {
AtomicReference<String> result = new AtomicReference<>();
for(String base: engines) {
String url = base + question;
new Thread(() -> {
result.compareAndSet(null, WS.url(url).get());
}).start();
}
while(result.get() == null); // wait for the result to appear
return result.get();
}

THREAD SAFETY
A piece of code is thread-safe if it only
manipulates shared data structures in
a manner that guarantees safe
execution by multiple threads at the
same time.
https://en.wikipedia.org/wiki/Thread_safety

COMMUNICATION
Objects & Fields
Atomics*
Queues
Database

COMMUNICATION
The Java Language
Specification
17.4. Memory Model

TAKEAWAY: THREADS
Threads take resources
Require manual management
Easy
Not so simple

EXECUTORS
public interface Executor {
void execute(Runnable command);
}
public interface ExecutorCompletionService<V> {
public Future<V> submit(Callable<V> task);
public Future<V> take();
}

EXECUTORS
private static String getFirstResultExecutors(String question, List<String>
engines) {
ExecutorCompletionService<String> service = new
ExecutorCompletionService<String>(Executors.newFixedThreadPool(4));
for(String base: engines) {
service.submit(() -> {
return WS.url(url).get();
});
}
try {
return service.take().get();
}
catch(InterruptedException | ExecutionException e) {
return null;
}
}

CONCERNS: EXECUTORS
Queue size
Overﬂow strategy
Cancellation strategy

TAKEAWAY: EXECUTORS
Simple conﬁguration
Bounded overhead
Pushing complexity deeper

http://i.ytimg.com/vi/6_W_xLWtNa0/maxresdefault.jpg

FORK JOIN FRAMEWORK
Recursive tasks
General parallel tasks
Work stealing

FORK JOIN FRAMEWORK
Method
Async execution execute(ForkJoinTask)
Await and get result invoke(ForkJoinTask)
Exec and get Future submit(ForkJoinTask)

FORK JOIN POOL
private static String getFirstResult(String question,
List<String> engines) {
// get element as soon as it is available
Optional<String> result = engines.stream()
.parallel().map((base) ->
{
}).findAny();
return result.get();
}

TAKEAWAY: FORK JOIN POOL
Eﬃcient
Preconﬁgured
Easy to get right
Easy to get wrong

COMPLETABLE FUTURES
private static String getFirstResultCompletableFuture(String question, List<String>
engines) {
CompletableFuture result = CompletableFuture.anyOf(engines.stream().map(
(base) -> {
return CompletableFuture.supplyAsync(() -> {
});
}
).collect(Collectors.toList()).toArray(new CompletableFuture[0]));
try {
return (String) result.get();
}
catch (InterruptedException | ExecutionException e) {
return null;
}
}

Using types
java.util.concurrent.CompletableFuture
thenApply(Function / Consumer / etc)
thenApplyAsync(Function / etc)

Completable Future
https://vimeo.com/131394616

ACTORS
static class Message {
String url;
Message(String url) {this.url = url;}
}
static class Result {
String html;
Result(String html) {this.html = html;}
}

ACTORS
static class UrlFetcher extends UntypedActor {
@Override
public void onReceive(Object message) throws Exception {
if (message instanceof Message) {
Message work = (Message) message;
String result = WS.url(work.url).get();
getSender().tell(new Result(result), getSelf());
} else {
unhandled(message);
}
}
}

ACTORS
public static interface Squarer {
//fire-forget
void squareDontCare(int i);
//non-blocking send-request-reply
Future<Integer> square(int i);
//blocking send-request-reply
Option<Integer> squareNowPlease(int i);
//blocking send-request-reply
int squareNow(int i);
}

TAKEAWAY: ACTORS
OOP is about messages
Multiplexing like a boss
Supervision & Fault tolerance

http://static1.squarespace.com/static/50aa813ce4b0726ad3f3fdb0/51e1e393e4b0180cf3bcbb46/51e1e39ae4b0fa94cee721f9/1373758363472/forest-by-marshmallow-laser-feast-the-tree-mag-30.jpg

TAKEAWAY: FIBERS
Continuations
Progress all over the place
Bytecode modiﬁcation
Highly scalable

TAKEAWAY: TX MEMORY
Optimistic writes
Retry / Fail
ACID

Seven Concurrency
Models in Seven
Weeks:
When Threads Unravel
by Paul Butcher
https://pragprog.com/book/pb7con/seven-concurrency-models-in-seven-weeks

http://www.amazon.com/The-Multiprocessor-Programming-Revised-Reprint/dp/0123973376
The Art of
Multiprocessor
Programming
by Maurice Herlihy, Nir Shavit

http://0t.ee/javadaykiev

oleg@zeroturnaround.com
@shelajev
Contact me

Flavors of Concurrency in Java

Recommended

More Related Content

What's hot (20)

Similar to Flavors of Concurrency in Java (20)

More from JavaDayUA (20)

Recently uploaded (20)

Flavors of Concurrency in Java