[JavaOne 2011] Models for Concurrent Programming
9 likes1,356 views
The document discusses models for concurrent programming. It summarizes common misconceptions about threads and concurrency, and outlines some of the core abstractions and tools available in Java for writing concurrent programs, including threads, monitors, volatile variables, java.util.concurrent classes like ConcurrentHashMap, and java.util.concurrent.locks classes like ReentrantLock. It also discusses some models not currently supported in Java like parallel arrays, transactional memory, actors, and Clojure's approach to concurrency using immutable data structures, refs, and atoms.
![ConcurrentMap<String,Thing> map =
new ConcurrentHashMap();
ą¹Adds atomic operations to the Map
interface:
- putIfAbsent(key, value)
- remove(key, value)
- replace(key,[oldVal,]newVal)
- but not yet
putIfAbsent(key, #{makeValue()})
ą¹CHM is lock striped, i.e. synchronized
on regions 22](https://image.slidesharecdn.com/24881-modelsforconcurrentprogramming-111019034625-phpapp02/85/JavaOne-2011-Models-for-Concurrent-Programming-25-320.jpg)
![public class CopyOnWriteArrayList<T>
private volatile Object[] array = new Object[0];
public synchronized boolean add(T value) {
Object[] newArray = Arrays.copyOf(array, array.length+1);
newArray[array.length] = value;
array = newArray; // write barrier
return true;
} // write barrier
public Iterator<T> iterator() {
return new ArrayIterator<T>(this.array); // read barrier
}
private static class ArrayIterator<T> implements Iterator<T> {
// Iāve written too many of these to be amused any more ...
}
24](https://image.slidesharecdn.com/24881-modelsforconcurrentprogramming-111019034625-phpapp02/85/JavaOne-2011-Models-for-Concurrent-Programming-27-320.jpg)
![(def x 10) ; create a root binding
(def x 42) ; redefine the root binding
(binding [x 13] ...) ; create a thread local override
48](https://image.slidesharecdn.com/24881-modelsforconcurrentprogramming-111019034625-phpapp02/85/JavaOne-2011-Models-for-Concurrent-Programming-55-320.jpg)
![(def street (ref))
(def city (ref))
(defn move [new-street new-city]
(dosync ; synchronize the changes
(ref-set street new-street)
(ref-set city new-city)))
; will retry if txn fails due to concurrent change
(defn print-address []
(dosync ; get a snapshot state of the refs
(printf "I live on %s in %s%n" @street @city)))
50](https://image.slidesharecdn.com/24881-modelsforconcurrentprogramming-111019034625-phpapp02/85/JavaOne-2011-Models-for-Concurrent-Programming-57-320.jpg)
![(defstruct address-t :street :city)
(def address (atom))
(defn move [new-street new-city]
(set address
(struct address-t new-street new-city)))
(defn print-address []
(let [addr @address] ; get snapshot
(printf "I live on %s in %s%n"
(get addr :street)
(get addr :city))))
52](https://image.slidesharecdn.com/24881-modelsforconcurrentprogramming-111019034625-phpapp02/85/JavaOne-2011-Models-for-Concurrent-Programming-59-320.jpg)
![(def account (agent))
(defn deposit [balance amount]
(+ balance amount))
(send account deposit 1000)
55](https://image.slidesharecdn.com/24881-modelsforconcurrentprogramming-111019034625-phpapp02/85/JavaOne-2011-Models-for-Concurrent-Programming-62-320.jpg)
[JavaOne 2011] Models for Concurrent Programming
- 1. Models for Concurrent Programming [email protected] Tobias Ivarsson twitter: @thobe web: http://thobe.org/ http://neo4j.org/ hacker @ Neo Technology
- 3. More threads == More throughput 3
- 4. Finite number of cores 4
- 5. Other limiting factors f.ex. I/O is only one pipe 5
- 6. Locking always impedes performance 6
- 7. Concurrency on the track, only one in the station 7
- 8. Amdahlās law 1 Speedup ā¤ 1-F F+ N N: Number of processors F: Serial fraction 8
- 9. Throughput with Throughput: 3 synchronized regions 9
- 10. Throughput with Throughput: 6 synchronized regions wait... 9
- 11. Throughput with synchronized Throughput: 9 regions wait... wait... 9
- 12. Throughput with synchronized Throughput: 11 regions wait... wait... wait... 9
- 13. Throughput with synchronized Throughput: 11 regions wait... wait... wait... wait... wait... wait... wait... wait... wait... wait... wait... 10
- 14. Throughput with synchronized regions Throughput: 11 wait... wait... wait... wait... wait... wait... wait... 11
- 15. The fundamentals ą¹Threads ą¹Mutual exclusion synchronization and locks ą¹Java Memory Model read/write barriers & publication 12
- 16. The Java Memory Model 1 33 What you need to know JSR ą¹ Visibility / Publication of objects/ļ¬elds ą¹ (Un)Acceptable out-of-order behavior i.e. guarantees about ordering ą¹ Implementations based on the hardware MM of the target platform 13
- 17. Concurrency abstractions 14
- 18. Java as we know it 15
- 19. Threads ą¹ Abstract the line of excution from the CPU(s) ą¹ Provided by most (all mainstream) operating systems ą¹ CPU execution can continue on another thread if one thread blocks ą¹ Increases CPU utilization 16
- 20. Monitors synchronized (someMonitor) { read barrier // single threaded region } write barrier 17
- 21. Volatile read/write 18
- 22. class Thing { volatile String name; String getName() { return this.name; read barrier } void setName( String newName ) { this.name = newName; write barrier } } ą¹ Guarantees visibility: always read the latest value ą¹Guarantees safe publication: no re-ordering of pre-write ops with post-write ops 19
- 23. Monitors synchronized (someMonitor) { read barrier // single threaded region } write barrier ą¹Writes may not be reordered across the end ą¹Reads may not be reordered across the start 20
- 24. java.util.concurrent 21
- 25. ConcurrentMap<String,Thing> map = new ConcurrentHashMap(); ą¹Adds atomic operations to the Map interface: - putIfAbsent(key, value) - remove(key, value) - replace(key,[oldVal,]newVal) - but not yet putIfAbsent(key, #{makeValue()}) ą¹CHM is lock striped, i.e. synchronized on regions 22
- 26. List<Thing> list = new CopyOnWriteArrayList(); ą¹Synchronize writers, unrestricted readers ą¹Good for: #reads >> #writes ą¹Readers get snapshot state: gives stable iteration ą¹Volatile variable for immutable state to ensure publication 23
- 27. public class CopyOnWriteArrayList<T> private volatile Object[] array = new Object[0]; public synchronized boolean add(T value) { Object[] newArray = Arrays.copyOf(array, array.length+1); newArray[array.length] = value; array = newArray; // write barrier return true; } // write barrier public Iterator<T> iterator() { return new ArrayIterator<T>(this.array); // read barrier } private static class ArrayIterator<T> implements Iterator<T> { // Iāve written too many of these to be amused any more ... } 24
- 28. ExecutorService executor = new ThreadPoolExecutor(); executor.submit(new Runnable() { ą¹ void run() { doWork(); Focus on tasks - not threads } }); ą¹Mitigate thread start/stop overhead ą¹Ensure a balanced number of threads for the target platform 25
- 29. java.util.concurrent.locks 26
- 30. LockSupport.park(); // currentThread LockSupport.unpark(Thread t); ą¹The thread will āsleepā until unparked ą¹Although unpark-before-park marks the thread as unparked, returning from park immediately ą¹... and thereās still the chance of spurious wakeups ... ą¹Too low level for most people 27
- 31. Lock lock = new ReentrantLock(); ReadWriteLock rwLock = new ReentrantReadWriteLock(); Lock read = rwLock.readLock(); // Two related locks Lock write = rwLock.writeLock(); lock.lock(); try { doWork() } finally { lock.unlock(); } if ( lock.tryLock() ) try { doWork() } finally { lock.unlock(); } else backOffAndTryAgainLater(); 28
- 32. java.util.concurrent.atomic 29
- 33. AtomicReference<Thing> ref = new AtomicReference(); AtomicReferenceArray<Thing> array = new AtomicReferenceArray(); 30
- 34. AtomicReference<Thing> ref = new AtomicReference(); AtomicReferenceArray<Thing> array = new AtomicReferenceArray(); class MyAtomicThingReference { volatile Thing thing; static AtomicReferenceFieldUpdater <MyAtomicThingReference,Thing> THING = newUpdater(...); Thing swap( Thing newThing ) { return THING.getAndSet( this, newThing ); } ą¹Atomic* gives you compareAndSet() } ą¹Atomic*Updater saves indirection: ą¹One less object header - less memory ą¹One read-address-get-object operation: better cache locality 30
- 35. Java of Tomorrow (actually Today, JDK7 is already out) 31
- 36. ForkJoin ą¹More āadvancedā Executor ą¹Assumes/requires more of the tasks it runs ą¹Tasks ļ¬rst split into multiple sub-tasks, push on stack ą¹Idle workers āstealā work from the bottom of the stack of other workers 32
- 37. Models not in Java today 33
- 38. ParallelArray 34
- 39. ParallelArray<Student> students = ... double highestScore = students .filter( #{ Student s -> s.gradYear == 2010 } ) .map( #{ Student s -> s.score } ) .max(); 35
- 40. Transactional Memory 36
- 41. void transfer( TransactionalLong source, TransactionalLong target, long amount ) { try ( Transaction tx = txManager.beingTransaction() ) { long sourceFunds = source.getValue(); if (sourceFunds < amount) { throw new InsufficientFundsException(); } source.setValue( sourceFunds - amount ); target.setValue( target.getValue() + amount ); tx.success(); } } 37
- 42. Actors 38
- 43. class SimpleActor extends Actor { var state def receive = { case Get => self reply state case Set(newState) => state = newState } } geā ans ssa āse s me me nd i Th val response = simple !! Set( "new state" ) 39
- 45. Efļ¬cient Collection splitting & combining 41
- 46. Efļ¬cient Collection splitting & combining 41
- 47. Efļ¬cient Collection splitting & combining 41
- 48. Efļ¬cient Collection splitting & combining 41
- 49. Splittable maps 15 5 174 2 8 42
- 50. Splittable maps 8 5 15 2 174 43
- 51. Hash tries ą¹Similar performance to hash tables ą¹Splittable (like arrays) ą¹Memory (re)allocation more like trees ą¹No resizing races 44
- 52. Clojure 45
- 53. Immutable by default 46
- 54. Thread local (and scoped) override 47
- 55. (def x 10) ; create a root binding (def x 42) ; redefine the root binding (binding [x 13] ...) ; create a thread local override 48
- 56. Transactional memory (ref) and (dosync ...) 49
- 57. (def street (ref)) (def city (ref)) (defn move [new-street new-city] (dosync ; synchronize the changes (ref-set street new-street) (ref-set city new-city))) ; will retry if txn fails due to concurrent change (defn print-address [] (dosync ; get a snapshot state of the refs (printf "I live on %s in %s%n" @street @city))) 50
- 58. (atom) easier API for AtomicReference 51
- 59. (defstruct address-t :street :city) (def address (atom)) (defn move [new-street new-city] (set address (struct address-t new-street new-city))) (defn print-address [] (let [addr @address] ; get snapshot (printf "I live on %s in %s%n" (get addr :street) (get addr :city)))) 52
- 61. (agent) A simpler cousin to actors 54
- 62. (def account (agent)) (defn deposit [balance amount] (+ balance amount)) (send account deposit 1000) 55
- 63. weāre hiring http://neotechnology.com/about-us/jobs http://neotechnology.com
- 64. Questions?