The document discusses various approaches for dealing with concurrency and parallelism in programming. It highlights that while threads and locks make concurrency difficult, there are better solutions like fork/join pools, dataflow programming, and actors. These approaches allow programmers to write code without worrying about threads and synchronization, making parallelism easier to implement. The key milestone approaches mentioned are asynchronous calculations, parallel collection processing using fork/join, dataflow programming using variables and streams, and using actors to isolate concurrent operations.

1. Concurrency pick the low-hanging fruit Václav Pech

2. About me Passionate programmer Concurrency enthusiast GPars @ Codehaus lead Groovy contributor Technology evangelist @ JetBrains JetBrains Academy member http://www.jroller.com/vaclav http://twitter.com/vaclav_pech

3. We’re all in the parallel computing business!

5. # of cores Today Soon

6. Dealing with threads sucks! public class Counter { private static long count = 0 ; public Counter() { count++; } }

7. Dealing with threads sucks! public class Counter { private static long count = 0 ; public Counter() { synchronized ( this ) { count++; } } }

8. Dealing with threads sucks! public class Counter { private static long count = 0 ; public Counter() { synchronized ( this .getClass()) { count++; } } }

9. Dealing with threads sucks! public class ClickCounter implements ActionListener { public ClickCounter(JButton button) { button.addActionListener( this ); } public void actionPerformed( final ActionEvent e) { ... } }

10. Dealing with threads sucks! Dead-locks, Live-locks, Race conditions, Starvation, ...

11. Can we do better? Map/Reduce Fork/Join Actors STM Dataflow Agent

12. Asynchronous invocation Future f = threadPool.submit (calculation); … System.out.println( “Result: “ + f.get()); main calculation get()

13. Thread Pool Tasks Worker threads Queue

14. Thread Pool Contention!

15. Fork/Join Thread Pool

16. Fork/Join Thread Pool Work stealing

17. Fork/Join Solve hierarchical problems Divide and conquer Merge sort, Quick sort

18. Tree traversal

19. File scan / search

20. … [a, b, c, d, e, f, g, h] [a, b, c, d] [e, f, g, h] [a, b] [c, d] [e, f] [g, h]

21. Collections (Groovy/GPars) images. eachParallel {it.process()} documents. sumParallel () candidates. maxParallel {it.salary}.marry()

22. Parallel Arrays (jsr-166y) ParallelArray namesOfWomen = people .withFilter( aWoman ).withMapping( retrieveName ).all(); Ops.Predicate aWoman = new Ops.Predicate() { public boolean op(Person friend) {return !friend.isMale();} }; Ops.Op retrieveName = new Ops.Op() { public Object op(Person friend) {return friend.getName();} };

23. Dataflow Concurrency No race-conditions

24. No live-locks

25. Deterministic deadlocks Completely deterministic programs BEAUTIFUL code (Jonas Bonér)

26. Dataflow Variables / Promises main task2 task3 x y z task1

27. DataFlows (GPars) def df = new DataFlows () task { df .z = df .x + df .y } task { df .x = 10 } task { println ”I am task 3”

28. df .y = 5

29. }

30. assert 15 == df .z

31. Composing async functions int hash1 = hash(download( 'http://www.gpars.org' )) int hash2 = hash(loadFile( '/gpars/website/index.html' )) boolean result = compare(hash1, hash2) println result

32. Composing async functions def hash = oldHash.asyncFun() def compare = oldCompare.asyncFun() def download = oldDownload.asyncFun() def loadFile = oldLoadFile.asyncFun() def hash1 = hash(download( 'http://www.gpars.org' )) def hash2 = hash(loadFile( '/gpars/website/index.html' )) def result = compare(hash1, hash2) println result .get()

33. Composing async functions int hash(String text ) {…} Promise<int> hash( Promise<String> | String text )

34. Composing async functions int hash(String text ) {…} Promise<int> hash( Promise<String> | String text ) { Return a Promise for the result