Writing concurrent code that is also correct is unbelievably hard. Naturally, humanity has developed a number of approaches to handle concurrency in the code, starting from basic threads that follow the hardware way to do concurrency to higher level primitives like fibers and work-stealing solutions. But which approach is the best for you? In this session, we'll take a look at a simple concurrent problem and solve it using different ways to manage concurrency: threads, executors, actors, fibers, monadic code with completable futures. All these approaches are different from the simplicity, readability, configuration and management point of view. Some scenarios are better modelled with threads, while sometimes you're better off with actors. We'll discuss the benefits of each approach and figure out when it's worth pursuing in your project.

1. Oleg Šelajev
@shelajev
ZeroTurnaround
Flavors of Concurrency in Java

2. whoami
@shelajev

4. WHY DO WE CARE?

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

6. DEVS CHOOSING TECHNOLOGY

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

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

9. THEORY

10. PRACTICE

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

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

13. PROBLEM ORIENTED PROGRAMMING

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

16. WHY THREADS
Model Hardware
Processes
Threads

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

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

19. COMMUNICATION
Objects & Fields
Atomics*
Queues
Database

20. COMMUNICATION

21. COMMUNICATION

22. COMMUNICATION
The Java Language
Specification
17.4. Memory Model

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

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

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

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

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

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

30. CONCERNS: EXECUTORS
Queue size
Overflow strategy
Cancellation strategy

31. TAKEAWAY: EXECUTORS
Simple configuration
Bounded overhead
Pushing complexity deeper

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

33. FORK JOIN FRAMEWORK
Recursive tasks
General parallel tasks
Work stealing

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

35. 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) ->
{
String url = base + question;
return WS.url(url).get();
}).findAny();
return result.get();
}

36. TAKEAWAY: FORK JOIN POOL
Efficient
Preconfigured
Easy to get right
Easy to get wrong

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

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

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

41. Completable Future
https://vimeo.com/131394616

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

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

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

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

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

48. FIBERS
Lightweight threads

50. TAKEAWAY: FIBERS
Continuations
Progress all over the place
Bytecode modification
Highly scalable

52. TRANSACTIONAL MEMORY

53. TAKEAWAY: TX MEMORY
Optimistic writes
Retry / Fail
ACID

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

55. CONCLUSION

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

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

58. http://0t.ee/javadaykiev

59. oleg@zeroturnaround.com
@shelajev
Contact me