Java Concurrency

1. Java Concurrency by Eric Burke burke.eric@gmail.com

2. i++ is not Atomic

3. AtomicInteger final AtomicInteger tally = new AtomicInteger(); int a = tally.get(); int b = tally.getAndIncrement(); int c = tally.incrementAndGet(); int d = tally.getAndAdd(20); etc… Useful as a mutable type wrapper

4. Atomic Variables java.util.concurrent.atomic • AtomicInteger, AtomicLong, AtomicBoolean, AtomicReference, etc… • set(), get(), incrementAndGet(), getAndIncrement(), addAndGet(int n), etc… • Enable nonblocking algorithms • Use atomic machine instructions • compare-and-swap

5. Swing • Components and models arethread-confined • SwingUtilities • invokeLater(Runnable) • invokeAndWait(Runnable) • isEventDispatchThread() • SwingWorker (Java 6)

6. SwingWorker final JLabel label; class MeaningOfLifeFinder extendsSwingWorker<String, Object> { public String doInBackground() { return findTheMeaningOfLife(); } protected void done() { try { label.setText(get()); } catch (Exception ignore) { } } } (new MeaningOfLifeFinder()).execute(); Example from SwingWorkerJavaDocs

7. SwingWorker Demo • Run DemoSwingWorker • Code Review

8. CopyOnWriteArraySet private final Set<ActionListener> listeners = new CopyOnWriteArraySet<ActionListener>(); public void addActionListener(ActionListener l) { listeners.add(l); } public void removeActionListener(ActionListener l) { listeners.remove(l); } private void notifyListeners(ActionEvent e) { for (ActionListener l : listeners) { l.actionPerformed(e); } }

9. ThreadFactory • Assign names to your threads • Better than “new Thread” • daemon status • priority • Provide an UncaughtExceptionHandler

10. ThreadFactoryExample DemoThreadFactory

11. Risks • Daemon threads • finally blocks do not execute at VM shutdown • ThreadLocal with thread pool • leak, leak, leak

12. Code Smells? • Abusing Thread.sleep() • Using SwingUtilities.invokeLater() for wrong reasons • GUI painting artifacts

13. Pre-Java 5 • Two ways to coordinate access to shared data: • synchronized, volatile • Problems with synchronized: • Cannot interrupt a thread that is waiting on a lock • Cannot attempt to acquire a lock without possibly blocking forever • Intrinsic locks must be released in the same block of code in which they were acquired

14. Lock Interface • Similar to intrinsic locking • provides mutual exclusion • same memory-visibility guarantees • Advantages • solves problems listed on previous slide

15. Lock Example Lock lock = new ReentrantLock(); lock.lock(); try { …do stuff here } finally { lock.unlock(); } Example 13.2 from “Java Concurrency in Practice” • Instead of lock(), you can call one of these: • booleantryLock() • booleantryLock(long timeout, TimeUnit unit) • lockInterruptibly()

16. Read-Write Locks • Multiple simultaneous readers • Only one writer • Great for “read-mostly” data structures See NameIdLookup.java

17. Immutability • Immutable objects are thread-safe • Does this pose a problem for modern POJO frameworks like Spring, JPA, Hibernate, and others? I use “final” wheneverI can

18. Exception Handling • Walk through the BlowUp demo

19. Interruption (1) public void run() { while (!Thread.currentThread().isInterrupted()) { …do something important } } Be careful: Calling Thread.interrupted() Clears the Flag

20. Interruption (2) Blocks public void run() { try { Message msg = myQueue.take(); …do something important } catch (InterruptedException ignored) { // let this thread complete } }

21. Interruption (3) void copy(InputStream in, OutputStream out) throws IOException { byte[] buf = new byte[BUFFER_SIZE]; intlen; while ((len = in.read(buf)) > 0) { out.write(buf, 0, len); if (Thread.currentThread().isInterrupted()) { throw new InterruptedIOException(); } } }

22. Some Interruption Tips • Interrupt a thread like this: • myThread.interrupt() • Thread.currentThread().interrupt() • myExecutorService.shutdownNow() • When looping, check if interrupted • Such as when downloading large files • When interrupted • Let your thread end, or propagate an InterruptedException

23. CountDownLatch • java.util.concurrent.CountDownLatch • constructor accepts a count await() countDown() Block until count reaches 0 Decrement the count See LatchDemo

24. CyclicBarrier • Similar to CountDownLatch • But can be reused over and over • Initialize with a count • Each thread calls await() • All released when count is reached See CyclicBarrierDemo

25. BlockingQueue • Useful for producer/consumer • Producer Thread(s) • queue.put(obj) • blocks until the queue has room • Consumer Thread(s) • queue.take() • blocks until an object is available in the queue See DonutDemo

26. ConcurrentHashMap • A thread-safe Map implementation • But not completely synchronized like Hashtable • Uses a technique called lock striping • Array of 16 locks internally • Up to 16 concurrent writers • ConcurrentMap<K,V> interface • V putIfAbsent(K key, V value) • boolean remove(K key, V value) • boolean replace(K key, V oldValue, V newValue) • V replace(K key, V newValue)

27. The End