Václav Pech is the lead of GPars, a concurrency library for Groovy. He discusses how languages are becoming increasingly concurrent to take advantage of multi-core processors. GPars supports various concurrency constructs including asynchronous functions, actors, dataflow programming, and parallel collections. It aims to provide concurrency without complexity through a unified API that hides low-level concurrency details.

1. GPars
Václav Pech
JetBrains

2. About me
['Passionate programmer',
'Concurrency enthusiast',
'GPars lead',
'Developer/technology evangelist @ JetBrains'
].eachParallel {say it}
http://www.jroller.com/vaclav
http://twitter.com/vaclav_pech

3. We're all parallel now
Use them or leave them!

5. # of cores
Tomorrow
Today

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

7. Languages are either concurrent or obsolete.

8. Java 5
Asynchronous calculations

9. Java 7
Asynchronous calculations
Fork/Join

10. Java 8
Asynchronous calculations
Fork/Join
Parallel collections

11. Scala
Asynchronous calculations
Fork/Join
Parallel collections
Actors

12. Clojure
Asynchronous calculations
Fork/Join
Parallel collections
Actors
Agents, Stm

13. Oz
Asynchronous calculations
Fork/Join
Parallel collections
Actors
Agents, Stm
Dataflow

14. Google's Go
Asynchronous calculations
Fork/Join
Parallel collections
Actors
Agents, Stm
Dataflow
CSP

15. Asynchronous calculations
Fork/Join
Parallel collections
Actors
Agents, Stm
Dataflow
CSP

16. Agenda
Asynchronous calculations
Fork/Join
Parallel collections
Actors
Agents, Stm
Dataflow
CSP

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

18. Asynchronous closures
def resize = {img -> img.resize(64, 64)}
def fastResize = resize.asyncFun()
def resized = fastResize(myImage)
…
resized.get()

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

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

21. Composing async functions
@AsyncFun hash = oldHash
@AsyncFun(blocking = true) compare = oldCompare
@AsyncFun download = oldDownload
@AsyncFun loadFile = oldLoadFile
def hash1 = hash(download('http://www.gpars.org'))
def hash2 = hash(loadFile('/gpars/website/index.html'))
boolean result = compare(hash1, hash2)
println result

22. int hash(String text) {…}
Promise<int> hash(Promise<String> | String text)

23. int hash(String text) {…}
Promise<int> hash(Promise<String> | String text) {
1. Return a Promise for the result
2. Wait (non-blocking) for the text param
3. Call the original hash()
4. Bind the result
}

24. Composing async functions
Combine functions as usual
Parallelism is detected automatically

25. Dataflow Concurrency
 No race-conditions
 No live-locks
 Deterministic deadlocks
Completely deterministic programs
BEAUTIFUL code
(Jonas Bonér)

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

27. Dataflows
def df = new Dataflows()
task { df.z = df.x + df.y }
task { df.x = 10 }
task {
println ”I am task 3”
df.y = 5
}
assert 15 == df.z

28. Dataflow Operators
operator(inputs: [headers, bodies, footers],
outputs: [articles, summaries])
{header, body, footer ->
def article = buildArticle(header, body, footer)
bindOutput(0, article)
bindOutput(1, buildSummary(article))
} *
<>
+

29. Dataflow Operators
Url resolver
Speculator Cache Downloader
updates
Evaluator
Approvals
Splitter
Groovy scanner Scala scanner
Reporter
Confirm

30. Actors
Actor
Actor
 Isolated Actor
Actor
Actor
 Communicating Actor
Actor
 Immutable messages
 Active
 Pooled shared threads
 Activities TT
 Createa new actor T
 Send a message Thread pool
 Receive a message

31. Stateless Actors (pure Java)
class MyActor extends DynamicDispatchActor {
private Account account = ...
public void onMessage(String msg) {
String encripted = encrypt(msg);
reply(encripted);
}
public void onMessage(Integer number) {
reply(2 * number);
}
public void onMessage(Money cash) {
System.out.println("Received a donation " + cash);
account.deposit(cash);
}
}

32. Active Objects
@ActiveObject
class MyCounter {
private int counter = 0
@ActiveMethod
def incrementBy(int value) {
println "Received an integer: $value"
this.counter += value
}
}

33. No more threads and locks
images.parallel.map {
//concurrency agnostic code here
}
def myActor = actor {
//concurrency agnostic code here
}
Identically with agents, fork/join, dataflow, …

34. GPars
'coz concurrency is Groovy
Find more at:
http://gpars.codehaus.org
http://www.jroller.com/vaclav
http://twitter.com/vaclav_pech