This document discusses concurrency patterns and issues in multi-threaded programming. It introduces common concurrency primitives like threads, mutexes, and condition variables. It describes problems that can occur with race conditions and memory consistency. Several patterns for managing concurrent access are explained, including fully synchronized objects, resource ordering, copy-on-write, partitioning, and lock-free queues. The document cautions that any pattern requiring complex analysis to prove thread-safety may be fragile.

1. Concurrency Patterns David Kemp Melbourne Patterns Group March 2010 Some rights reserved: Creative Commons Attribution-Noncommercial-Share Alike http://creativecommons.org/licenses/by-nc-sa/3.0/

2. Concurrency: what and why?

3. Thread Thread Stack Code Heap Stack

4. Issues

5. Race Conditions public class BankAccount { private int balance; public void adjustBalance(int amount) { balance = balance + amount; } ... }

8. If Possible: Avoid Concurrency!!

9. Concurrency Primitives

10. Threads (in Java) Runnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start(); interface Runnable { void run(); } Looks strangely like the command pattern (covered last month). The Java ExecutorService interface is even more like the Command Pattern.

11. Mutex (Mutual Exclusion Lock)

12. Mutexes can fix race conditions public class BankAccount { Object lock = new Object(); int balance; public void adjustBalance(int amount) { synchronize(lock) { balance = balance + amount; } }

14. If you need clever analysis to show thread safety, then it is either broken now, or will be broken by some future maintainer!!!!

16. Some Patterns

17. Fully Synchronized Objects Photo by Kevin Hamm. Some rights reserved. See: http://www.flickr.com/photos/krhamm/171302278/in/set-72157594171880205/

18. Fully Synchronized Object All methods on a fully synchronized object are synchronized on a single lock.

19. Resource Ordering Image by Benjamin D. Esham for the Wikimedia Commons. Some rights reserved. See: http://en.wikipedia.org/wiki/File:Dining_philosophers.png/

20. Copy-on-write

22. Partitioning

27. Double check locking (Warning: did not work before Java 1.5) volatile Properties properties = null; final Object lock = new Object(); public Properties getProperties() { if (properties == null) { synchronized (lock) { if (properties == null) { tmp = new Properties(); tmp.load(inputStream); properties = tmp; } } } return properties; } Possibly broken! Definitely Brittle!

28. Lock-free Queue

29. Lock Free Queue Queue Dummy Node Real Head Node Tail Penultimate node Head Tail : Might point to last or second last node! References are all updated using the Atomic Test-And-Set.