The document discusses various approaches for leveraging parallelism and concurrency including multithreading, fork/join, actors, dataflow, and software transactional memory. It notes that while multithreading is challenging, other approaches like actors, dataflow, and STM can allow for writing concurrency-agnostic code. It promotes the GPars library for its implementations of various parallel and concurrent programming abstractions in Java and Groovy.

1. Concurrency Unleash your processor(s) Václav Pech

2. About me Passionate programmer

3. Concurrency enthusiast

4. GPars @ Codehaus lead

5. Technology evangelist @ JetBrains

6. JetBrains Academy member http://www.jroller.com/vaclav http://twitter.com/vaclav_pech

7. The evil accumulator int sum=0;

8. for(int i : collection) sum += i;

9. We’re quad core already Beware: More cores to come shortly!

10. Stone age of parallel SW Dead-locks

11. Live-locks

12. Race conditions

13. Starvation

14. Shared Mutable State

15. Lock and synchronize Multithreaded programs today work mostly by accident!

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

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

18. Thread Pool Tasks Worker threads Queue

19. Thread Pool Contention!

20. Fork/Join Thread Pool

21. Fork/Join Thread Pool Work stealing

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

23. Tree traversal

24. File scan / search

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

26. Fork/Join (GPars) runForkJoin(new File( “./src” )) {currentDir -> long count = 0; currentDir.eachFile { if (it.isDirectory()) { println "Forking a thread for $it" forkOffChild it } else { count++ } } return count + childrenResults .sum(0) } Waits for children without blocking the thread!

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

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

29. Dataflow Concurrency No race-conditions

30. No live-locks

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

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

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

34. df .y = 5

35. }

36. assert 15 == df .z

37. Milestone Asynchronous background tasks

38. Fork/Join

39. Parallel collection processing

40. Dataflow variables/streams

41. Message Passing Communicating Sequential Processes (CSP) Dataflow Operators Actors

42. Dataflow Operators (GPars) operator(inputs: [stocksStream], outputs: [pricedStocks]) { stock -> def price = getClosing( stock , 2008) bindOutput(0, [stock: stock , price: price ]) } * + <>

43. Actors Isolated

44. Communicating Immutable messages Active Pooled shared threads Activities Create a new actor

45. Send a message

46. Receive a message Actor Actor Actor Actor Actor Actor Actor T T T Thread pool

47. Actors use Gate Keeper Form HTTP Finger Prints Address Check Email Check Process Fraud Detect Response SOAP SMTP

48. Actors patterns Enricher Router Translator Endpoint Splitter Aggregator Filter Resequencer Checker

49. Creating Actors (GPars) class MyActor extends AbstractPooledActor { void act() { def buddy = new YourActor().start() buddy << ‘Hi man, how\’re things?’ def response = receive () } }

50. Creating Actors (Scala) val me = actor { loop { react { case w:Work=>reply “I don't work so early”

51. case b:Breakfast=>

52. b.eat

53. react { case w:Work=>reply “OK, time to work” ; w.do case l:Lunch=>

54. ...

55. } } } }

56. me ! cake

57. Implicit State in Actors val me = actor { loop { react { case w:Work=>reply “I don't work so early”

58. case b:Breakfast=>

59. b.eat

60. react { case w:Work=>reply “OK, time to work” ; w.do case l:Lunch=>

61. ...

62. } } } }

63. me ! cake

64. Continuation Style loop { … react { … react { /*schedule the block; throw CONTINUE*/ … } //Never reached } //Never reached } //Never reached

65. Stateless Actors (GPars - Java) class MyActor extends DynamicDispatchActor { Account account = ...

66. public void onMessage(String msg ) {

67. String encripted = encrypt( msg );

68. reply( encripted );

69. }

70. public void onMessage(Integer number ) {

71. reply(2 * number );

72. }

73. public void onMessage(Money cash ) {

74. System.out.println( &quot;Received a donation &quot; + cash );

75. account .deposit( cash );

76. }

77. }

78. Stateless Actors (Akka - Scala) class MyActor extends Actor { def receive = { case &quot;Hello&quot; => reply(&quot;World&quot;) case Register(user, sender) => val registrationCode = register(user) sender ! SuccessfulRegistration(registrationCode) case _ => throw new RuntimeException(&quot;unknown message&quot;) } } Example form http://doc.akkasource.org/actors

79. Stateless Actors (Jetlang) Fiber fiber = new ThreadFiber(); fiber .start(); Channel<String> channel = new MemoryChannel<String>(); Callback<String> runnable = new Callback<String>() { public void onMessage (String msg) { log(msg.toUpperCase()); } }; channel.subscribe( fiber , runnable ); channel.publish( &quot;hello&quot; ); Based on sample code from http://code.google.com/p/jetlang/

80. Java actor frameworks Jetlang Kilim ActorFoundry Actorom Akka GPars (Yes!)

81. …

82. Shared Mutable State Misused most of the time When really needed, use Agents

83. Software Transactional Memory

84. Locks

85. Agent Lock Shared Mutable State in a Safe Alter the State Alter the State

86. Agent inside Double Increment Add 25 Message Queue 36 thread

87. Agent (ScalaAgent) def increment(x: Long) = x + 1 def decrement(delta : Long)(x: Long) = x - delta val agent = Agent(0L) agent (increment _) agent (decrement(3) _) agent {_ + 100} println( agent get)

88. STM (Akka - Scala) atomic { .. // do something within a transaction } atomic (maxNrOfRetries) { .. } atomicReadOnly { .. } atomically { .. // try to do something } orElse { .. // if tx clash; try do do something else } Sample taken from Akka documentation - http://doc.akkasource.org/stm

89. Persistent Data Structures Illustration taken from Rich Hickey's presentation. Copyright Rich Hickey 2009

90. No more threads and locks images. eachParallel { //concurrency agnostic code here } def myActor = actor { //concurrency agnostic code here } atomic { /*concurrency agnostic code here*/ } …

91. Summary Parallelism is not hard, multi-threading is

92. Jon Kerridge, Napier University

93. Tips Java JSR-166y - Fork/Join, Parallel Arrays

94. Multiverse, Jetlang, Kilim, Actorom, ActorFoundry, ...

95. GPars Clojure STM, Atoms, Agents, Promises Scala Actors, Akka, ScalaAgent Groovy GPars – actors, agent, dataflow, fork/join, map/reduce

96. Questions?

97. Find more at: http://gpars.codehaus.org

98. http://www.jroller.com/vaclav

99. http://twitter.com/vaclav_pech