1. The document discusses various approaches for writing concurrent and thread-safe code in Java, including using threads, immutable objects, volatile variables, and classes from the java.util.concurrent package. 2. It recommends using high-level concurrency utilities first before lower-level locking, and describes classes like ExecutorService, BlockingQueue, ConcurrentHashMap, and CopyOnWriteArrayList. 3. The document also covers the producer-consumer pattern as an example and introduces the fork/join framework that will be included in JDK 7 for parallelizing recursive tasks.

1. JavaConcurrencyRahul RevoGarrett ShortCreative MindaysMarch 3, 2011

2. Why care about ConcurrencyThe free lunch is over – Herb SutterMulti-core processors are hereApplications need to be concurrent to exploit CPUsMarch 2005 http://www.gotw.ca/publications/concurrency-ddj.htm23 March 2011

3. Language support for concurrencyThreads – C, C++, Java …Actors – ErlangSingle thread and WebWorker - JavascriptJavaThreading support in core libraryMonitor based synchronizationand new concurrency APIs33 March 2011

4. Thread safe code 1Manage access to shared mutable dataWhyOrder of executionStale data visibleAtomicity43 March 2011x= y = 0Thread 1Thread 2y = 1 j = xx = 1i = yCan i = 0 and j = 0 ?

5. Thread safe code 2Manage access to shared mutable dataHowDon’t share state variables across threadsUse java.lang.ThreadLocalMake objects immutableGuard access53 March 2011

6. volatileReads and writes provide correct visibilityHappens-before relationship, like a synchronized blockclass Worker implements Runnable { private volatileboolean cancelled = false; run() { while(!cancelled) { //do work } } cancel() { cancelled = true; }}63 March 2011

7. Immutable ObjectsAn object is immutable ifState cannot be modified after constructionAll fields are finalthis reference does not escape during construction73 March 2011class Cart { private List<String> items; public Cart(List items) { this.items = items; } public List getItems() { return items; }}class ImmutableCart { private final List<String> items; public ImmutableCart(List<String> thoseItems) { items = Collections.unmodifiableList(new ArrayList<>(thoseItems)); } public List getItems() { return items; }}

8. Annotations@GuardedBy(“some-lock-or-var”)The field or method can only be accessed when holding a particular lock@ImmutableIts state cannot be seen to change by callers@NotThreadSafeClarifying the non-thread-safety of a class that might otherwise be assumed to be thread-safe@ThreadSafeThis means that no sequences of accesses may put the object into an invalid state, regardless of the interleaving of those actions without requiring any additional synchronization on the part of the caller.83 March 2011

9. java.util.concurrentCollectionsBlockingQueueConcurrentMapCopyOnWriteTask ExecutionExecutor, ExecutorServiceExecutorsCallableFuture93 March 2011

10. Consumer:synchronized (obj) { while (! workToDo) {obj.wait(); } // get next item from the queueworkToDo = false; }// do work on the itemProducer:synchronized (obj) { if (! workToDo) { // add work to queueworkToDo = true; }obj.notifyAll();}103 March 2011Producer-Consumer Pattern 1

11. class Producer implements Runnable { private final BlockingQueue queue; Producer(BlockingQueue q) { queue = q; } public void run() { while (true) {queue.put(produce()); } } private Object produce() { ... } }113 March 2011Producer-Consumer Pattern 3

12. class Consumer implements Runnable { private final BlockingQueue queue; Consumer(BlockingQueue q) { queue = q; } public void run() { while (true) {consume(queue.take()); } } private void consume(Object x) { ... } }123 March 2011Producer-Consumer Pattern 4

13. 133 March 2011void main() {BlockingQueue q = new SomeQueueImplementation(); Producer p = new Producer(q); Consumer c1 = new Consumer(q); Consumer c2 = new Consumer(q); new Thread(p).start(); new Thread(c1).start(); new Thread(c2).start();}Producer-Consumer Pattern 2

14. Concurrent HashMap1Completely plug-compatible, implements the same Map interface we all know and love today.All operations are thread-safe, however retrieval operations do not involve locking the entire table. No ConcurrentModificationException! Creation of the an iterator or some enumeration reflect the state at that time. Note: iterators are intended to be used by only one thread at a time. Resizing is relatively slow operation, so try to provide good estimates of expected table sizes in constructors. A new optional 'concurrencyLevel' constructor argument (default 16), which is used as a hint for internal sizing. The value is the estimated number of concurrent updating threads. A value of 1 is appropriate there is only one writer and all other threads are readers. 143 March 2011

15. Concurrent HashMap2Add an item in a hash map only if it doesn’t already existOld way:synchronize (obj) {if (! map.containsKey(key)) {map.put(key, value);}}New Way:map.putIfAbsent(key, value);153 March 2011

16. Concurrent 3Additional methods beyond HashMapboolean remove(Object key, Object value)If this key is mapped to this value, remove it.V replace(K key, V value)If this key is mapped to any value, then map it instead to this new value. booleanreplace(K key, V oldValue, V newValue)If this key is mapped to this old value, then map it to this new value.163 March 2011

17. CopyOnWriteArrayListCopyOnWriteArrayList makes a fresh copy of the underlying array for mutative operations like addUse when lots of reads vs writes like event listenersList list1 = new CopyOnWriteArrayList(...);List list2 = new ArrayList(...);Iterator itor1 = list1.iterator();Iterator itor2 = list2.iterator();list1.add("New");list2.add("New");printAll(itor1);printAll(itor2); // throws ConcurrentModificationException173 March 2011

18. Collection ClassesDo not use the old synchronized classes:Vector, Stack, HashtableUse the non-synchronized version when that’s all you need:Arraylist, LinkedList, HashMapWhen Synchronization is needed, use the new java.util.concurrentclasses:ArrayBlockingQueue, LinkedBlockingQueue, ConcurrentHashMap183 March 2011

19. Task Execution 1Decouple the task submission from task execution by using an ExecutorDefine an execution policyIn what thread will execution happenWhat is the order of execution How many tasks run concurrently193 March 2011

20. Task Execution 2203 March 2011class ThreadPerTaskExecutor implements Executor { public void execute(Runnable r) { new Thread(r).start(); }}class DirectExecutor implements Executor { public void execute(Runnable r) {r.run(); } }Executor executor = anExecutor; executor.execute(new Runnable1());executor.execute(new Runnable2());And...FixedThreadPoolCachedThreadPoolScheduledThreadPool

21. ExecutorServiceMethods provided for shutdownGet status of tasks via FutureExecutorService extends Executor { void execute(Runnable r); Future<T> submit(Callable<T> t …); void shutdown();booleanisShutdown();booleanisTerminated();}213 March 2011

22. What’s the FutureCallable – Runnable on steroidsCallable<V> { V call() throws Exception;}Future – result of an asynchronous computationFuture<V> { V get();boolean cancel();booleanisCancelled();booleanisDone();}223 March 2011

23. Asynchronous resultsclass QuoteProcessor {ExecutorService exec = ...processQuotes() { List<QuoteTask> tasks = ... List<Future<TravelQuote>> futures = exec.invokeAll(tasks); List<TravelQuote> quotes = new ArrayList<>(); for(Future<TravelQuote> f : futures)quotes.add(f.get()); return quotes; }}233 March 2011

24. Scheduled ProcessingUse ScheduledThreadPoolExecutor instead of java.util.Timerexecutor = new ScheduledThreadPoolExecutor();executor.scheduleWithFixedDelay(new BatchProcess(), 10, 10, unit);// executor.scheduleWithFixedRate(...)// other threads are adding to this queue:queue = new LinkedBlockingDeque();class BatchProcess implements Runnable { public void run() { List data = new ArrayList ();queue.drainTo(data); // process data list in a batch }}243 March 2011

25. ThreadPoolExecutorThreadPoolExecutor configurationsCore and maximum pool On-demand constructionCreating new threadsKeep-alive timesQueueRejected tasksHook methodsQueue maintenanceFinalization253 March 2011

26. More concurrent APIsLocksConditionLockReadWriteLockReentrantLockAtomicBoolean, longMiscellaneousSemaphore, Barriers263 March 2011

27. Fork Join (coming in JDK 7)The fork/join framework is designed to make divide-and-conquer algorithms easy to parallelize.For example, recursive algorithms where the control path branches out over a few paths and they each process a part of the data set. The typical setup is a new class is created that extends either the RecursiveActionor RecursiveTaskclass. 273 March 2011

28. Fork Join Exampleclass ForkJoinMain { main() {ForkJoinPool pool = new ForkJoinPool();int[] data = [data set]; long sum = pool.invoke( new SumTask(data, 0, data.length - 1)); long sumSquares = pool.invoke( new SumSquaresTask(data, 0, data.length - 1)); long max = pool.invoke( new MaxTask(data, 0, data.length - 1)); }}283 March 2011

29. Fork Join Exampleabstract class AbstractExampleTask extends RecursiveTask<Long> {AbstractExampleTask(int[] data, intfirstIndex, intlastIndex) { ... } Long compute() { if (getLength() < THRESHOLD) { return directlySolve(); }AbstractExampleTask left = getSubtask(first, half()-1);AbstractExampleTask right = getSubtask(half(), last);left.fork();right.fork(); return handleResults(left.join(), right.join()); }}293 March 2011

30. class SumSquaresTask extends AbstractExampleTask {SumSquaresTask(...) { ... } Long directlySolve() { long accum = 0L; for (int i = 0; i < getLength(); i++) {accum = accum + (get(i) * get(i)); } return accum; } Long handleResults(Long leftLong, Long rightLong) { return leftLong + rightLong; }AbstractExampleTaskgetSubtask(int start, int end) { return new SumSquaresTask(data, start, end); }}303 March 2011Fork Join Example

31. SummaryRecommended order of useUse high level java.util.concurrent APIsLow level locking with synchronizationVolatile variables and java.util.concurrent.atomic classesPrefer correctness over speed313 March 2011

32. Q&A323 March 2011