Concurrency

Transcript

1. Java Concurrency Harshit Bangar Credit - Douglas Hawkins
2. Quiz - Identify thread safe APIs • behaviorSubject.onNext(“string”); • SharedPreferences • long height = 64L • x += 1 • Point point = new Point();
3. Quiz - Identify thread safe APIs • behaviorSubject.onNext(“string”); • SharedPreferences • long height = 64L • x += 1 • Point point = new Point();
4. Quiz - Identify thread safe APIs • behaviorSubject.onNext(“string”); • SharedPreferences • long height = 64L • x += 1 • Point point = new Point();
5. Quiz - Identify thread safe APIs • behaviorSubject.onNext(“string”); • SharedPreferences • long height = 64L • x += 1 • Point point = new Point();
6. Quiz - Identify thread safe APIs • behaviorSubject.onNext(“string”); • SharedPreferences • long height = 64L • x += 1 • Point point = new Point();
7. Quiz - Identify thread safe APIs • behaviorSubject.onNext(“string”); • SharedPreferences • long height = 64L • x += 1 • Point point = new Point();
9. –An engineer from Google “ If you're having problems with people assuming thread safety where none exists I'd worry about a lot more of your codebase than just views”
10. Content
11. Content • Atomicity
12. Content • Atomicity • Visibility
13. Content • Atomicity • Visibility • Thread Safety
14. Content • Atomicity • Visibility • Thread Safety • Designing a thread safe class
15. Content • Atomicity • Visibility • Thread Safety • Designing a thread safe class • Java Memory Model
34. Final & Freeze class FinalWrapperFactory { private FinalWrapper w; public Singleton get() { if (w == null) { // check 1 synchronized(this) { if (w == null) { // check2 w = new FinalWrapper(new Singleton()); } } } return w.instance; } private static class FinalWrapper { public final Singleton instance; public FinalWrapper(Singleton instance) { this.instance = instance; } } }
35. Final & Freeze class FinalWrapperFactory { private FinalWrapper w; public Singleton get() { if (w == null) { // check 1 synchronized(this) { if (w == null) { // check2 w = new FinalWrapper(new Singleton()); } } } return w.instance; } private static class FinalWrapper { public final Singleton instance; public FinalWrapper(Singleton instance) { this.instance = instance; } } }
36. Final & Freeze class FinalWrapperFactory { private FinalWrapper w; public Singleton get() { if (w == null) { // check 1 synchronized(this) { if (w == null) { // check2 w = new FinalWrapper(new Singleton()); } } } return w.instance; } private static class FinalWrapper { public final Singleton instance; public FinalWrapper(Singleton instance) { this.instance = instance; } } }
37. Final & Freeze class FinalWrapperFactory { private FinalWrapper w; public Singleton get() { if (w == null) { // check 1 synchronized(this) { if (w == null) { // check2 w = new FinalWrapper(new Singleton()); } } } return w.instance; } private static class FinalWrapper { public final Singleton instance; public FinalWrapper(Singleton instance) { this.instance = instance; } } }
41. Mutable state There are three ways to fix it:
42. Mutable state There are three ways to fix it: • Use synchronisation whenever accessing the state variable.
43. Mutable state There are three ways to fix it: • Use synchronisation whenever accessing the state variable. • Don't share the state variable across threads;
44. Mutable state There are three ways to fix it: • Use synchronisation whenever accessing the state variable. • Don't share the state variable across threads; • Make the state variable immutable; or
45. Factorizer public class Factorizer extends GenericServlet implements Servlet { public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = factor(i); encodeIntoResponse(resp, factors); } }
46. Factorizer public class Factorizer extends GenericServlet implements Servlet { public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = factor(i); encodeIntoResponse(resp, factors); } }
47. Factorizer public class Factorizer extends GenericServlet implements Servlet { private long count = 0; public long getCount() { return count; } public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = factor(i); ++count; encodeIntoResponse(resp, factors); } }
48. Factorizer public class Factorizer extends GenericServlet implements Servlet { private long count = 0; public long getCount() { return count; } public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = factor(i); ++count; encodeIntoResponse(resp, factors); } }
49. Factorizer public class Factorizer extends GenericServlet implements Servlet { private final AtomicLong count = new AtomicLong(0); public long getCount() { return count; } public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = factor(i); count.incrementAndGet(); encodeIntoResponse(resp, factors); } }
51. Concurrent Stack public class ConcurrentStack <E> { AtomicReference<Node<E>> top = new AtomicReference<Node<E>>(); public void push(E item) { Node<E> newHead = new Node<E>(item); Node<E> oldHead; do { oldHead = top.get(); newHead.next = oldHead; } while (!top.compareAndSet(oldHead, newHead)); } public E pop() { Node<E> oldHead; Node<E> newHead; do { oldHead = top.get(); if (oldHead == null) return null; newHead = oldHead.next; } while (!top.compareAndSet(oldHead, newHead)); return oldHead.item; } }
52. Concurrent Stack public class ConcurrentStack <E> { AtomicReference<Node<E>> top = new AtomicReference<Node<E>>(); public void push(E item) { Node<E> newHead = new Node<E>(item); Node<E> oldHead; do { oldHead = top.get(); newHead.next = oldHead; } while (!top.compareAndSet(oldHead, newHead)); } public E pop() { Node<E> oldHead; Node<E> newHead; do { oldHead = top.get(); if (oldHead == null) return null; newHead = oldHead.next; } while (!top.compareAndSet(oldHead, newHead)); return oldHead.item; } }
53. Concurrent Stack public class ConcurrentStack <E> { AtomicReference<Node<E>> top = new AtomicReference<Node<E>>(); public void push(E item) { Node<E> newHead = new Node<E>(item); Node<E> oldHead; do { oldHead = top.get(); newHead.next = oldHead; } while (!top.compareAndSet(oldHead, newHead)); } public E pop() { Node<E> oldHead; Node<E> newHead; do { oldHead = top.get(); if (oldHead == null) return null; newHead = oldHead.next; } while (!top.compareAndSet(oldHead, newHead)); return oldHead.item; } }
54. Factorizer public class Factorizer extends GenericServlet implements Servlet { public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = factor(i); encodeIntoResponse(resp, factors); } }
55. Factorizer public class Factorizer extends GenericServlet implements Servlet { private final AtomicReference<BigInteger> lastNumber = new AtomicReference<BigInteger>(); private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<BigInteger[]>(); public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); if (i.equals(lastNumber.get())) encodeIntoResponse(resp, lastFactors.get()); else { BigInteger[] factors = factor(i); lastNumber.set(i); lastFactors.set(factors); encodeIntoResponse(resp, factors); } } }
56. Factorizer public class Factorizer extends GenericServlet implements Servlet { private final AtomicReference<BigInteger> lastNumber = new AtomicReference<BigInteger>(); private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<BigInteger[]>(); public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); if (i.equals(lastNumber.get())) encodeIntoResponse(resp, lastFactors.get()); else { BigInteger[] factors = factor(i); lastNumber.set(i); lastFactors.set(factors); encodeIntoResponse(resp, factors); } } }
57. –Commandment #1 “To preserve state consistency, update related state variables in a single atomic operation.”
58. Factorizer public class Factorizer extends GenericServlet implements Servlet { @GuardedBy("this") private BigInteger lastNumber; @GuardedBy("this") private BigInteger[] lastFactors = new BigInteger[]{}; public synchronized void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); if (i == lastNumber) encodeIntoResponse(resp, lastFactors); else { BigInteger[] factors = factor(i); lastNumber = i; lastFactors = factors; encodeIntoResponse(resp, factors); } } }
59. Factorizer public class Factorizer extends GenericServlet implements Servlet { @GuardedBy("this") private BigInteger lastNumber; @GuardedBy("this") private BigInteger[] lastFactors = new BigInteger[]{}; public synchronized void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = null; synchronized (this) { if (i.equals(lastNumber)) { factors = lastFactors.clone(); } } if (factors == null) { factors = factor(i); synchronized (this) { lastNumber = i; lastFactors = factors.clone(); } } encodeIntoResponse(resp, factors); } }
60. Synchronized public class SynchronizedDemo { public synchronized void update() { } }
61. Synchronized public class SynchronizedDemo { public synchronized void update() { synchronized (this) { } } }
62. Synchronized public class SynchronizedDemo { private Object lock = new Object(); public synchronized void update() { synchronized (lock) { } } }
63. Synchronized public class SynchronizedDemo { @GuardedBy("lock") Integer counter1; private Object lock = new Object(); public void update() { synchronized (lock) { if (counter1 > Integer.MAX_VALUE) { return; } counter1 = counter1 + 1; } } }
64. Synchronized public class SynchronizedDemo { @GuardedBy("lock") Integer counter1; @GuardedBy("lock2") Integer counter2; private Object lock = new Object(); private Object lock2 = new Object(); public void update() { } public void update2() { synchronized (lock2) { if (counter2 > Integer.MAX_VALUE) { return; } counter2 = counter2 + 1; } } }
65. Synchronized public class SynchronizedDemo extends BaseUpdate { public synchronized void update() { super.update(); } } class BaseUpdate { public synchronized void update() { } }
66. Locking
67. Locking • Prefer explicit locking. Exception - superclass uses synchronised keyword, private lock will be unusable for subclasses
68. Locking • Prefer explicit locking. Exception - superclass uses synchronised keyword, private lock will be unusable for subclasses • Locks are reentrant.
69. Locking • Prefer explicit locking. Exception - superclass uses synchronised keyword, private lock will be unusable for subclasses • Locks are reentrant. • Add annotation @GuardedBy(“CorrectLock”) for documentation.
70. Locking • Prefer explicit locking. Exception - superclass uses synchronised keyword, private lock will be unusable for subclasses • Locks are reentrant. • Add annotation @GuardedBy(“CorrectLock”) for documentation. • Perform all operations on a single variable using the same lock.
71. Locking • Prefer explicit locking. Exception - superclass uses synchronised keyword, private lock will be unusable for subclasses • Locks are reentrant. • Add annotation @GuardedBy(“CorrectLock”) for documentation. • Perform all operations on a single variable using the same lock. • Perform all operations on related variables using the same lock. (i.e. Unrelated variables can have different locks)
73. Thread Confinement BehaviorSubject<String> timerSubject = BehaviorSubject.create(); Observable .timer(4, TimeUnit.SECONDS) .subscribe(aLong -> { timerSubject.onNext(String.valueOf(aLong)); });
74. Thread Confinement BehaviorSubject<String> timerSubject = BehaviorSubject.create(); Observable .timer(4, TimeUnit.SECONDS, Schedulers.computation()) .subscribe(aLong -> { timerSubject.onNext(String.valueOf(aLong)); }); * <p>All methods except the onSubscribe, onNext, onError and onComplete are thread-safe. * Use {@link #toSerialized()} to make these methods thread- safe as well.
75. Thread Confinement Subject<String> timerSubject = BehaviorSubject.create().serialized(); Observable .timer(4, TimeUnit.SECONDS, Schedulers.computation()) .subscribe(aLong -> { timerSubject.onNext(String.valueOf(aLong)); }); * <p>All methods except the onSubscribe, onNext, onError and onComplete are thread-safe. * Use {@link #toSerialized()} to make these methods thread- safe as well.
76. Thread Confinement Scheduler scheduler = Schedulers.single(); BehaviorSubject<String> timerSubject = BehaviorSubject.create(); Observable .timer(4, TimeUnit.SECONDS, Schedulers.computation()) .observeOn(scheduler) .subscribe(aLong -> { timerSubject.onNext(String.valueOf(aLong)); }); * <p>All methods except the onSubscribe, onNext, onError and onComplete are thread-safe. * Use {@link #toSerialized()} to make these methods thread- safe as well.
77. RX-Java Thread Safety
78. RX-Java Thread Safety • Subjects are not thread safe.
79. RX-Java Thread Safety • Subjects are not thread safe. • Most of the operators with single observable are not thread safe ex - take(N)
80. RX-Java Thread Safety • Subjects are not thread safe. • Most of the operators with single observable are not thread safe ex - take(N) • Most of the operators with multiple observable are thread safe ex- merge, concat
81. RX-Java Thread Safety • Subjects are not thread safe. • Most of the operators with single observable are not thread safe ex - take(N) • Most of the operators with multiple observable are thread safe ex- merge, concat • Details - blog
82. Visibility boolean run = false; int x = 42; public void thread1() { Thread thread = new Thread(new Runnable() { @Override public void run() { while (!run) { } System.out.println(x); } }); thread.start(); } public void thread2() { x = 100; run = true; }
83. Visibility boolean run = false; int x = 42; public void thread1() { Thread thread = new Thread(new Runnable() { @Override public void run() { while (!run) { } System.out.println(x); } }); thread.start(); } public void thread2() { x = 100; run = true; } // Output - Never terminate, 42, 100
84. Visibility volatile boolean run = false; volatile int x = 42; public void thread1() { Thread thread = new Thread(new Runnable() { @Override public void run() { while (!run) { } System.out.println(x); } }); thread.start(); } public void thread2() { x = 100; run = true; } // Output - 100
88. –Commandment #2 “Locking can guarantee both visibility and atomicity; volatile variables can only guarantee visibility.”
89. Put if Absent public class MapExample<K, V> { Map<K, V> myMap = new ConcurrentHashMap<>(); public V addIfAbsent(K key, V value) { if (!myMap.containsKey(key)) { myMap.put(key, value); } return myMap.get(key); } }
90. Put if Absent public class MapExample<K, V> { Map<K, V> myMap = new ConcurrentHashMap<>(); public V addIfAbsent(K key, V value) { if (!myMap.containsKey(key)) { myMap.put(key, value); } // Non - Atomic return myMap.get(key); } }
91. Put if Absent public class MapExample<K, V> { Map<K, V> myMap = new ConcurrentHashMap<>(); public synchronized V addIfAbsent(K key, V value) { if (!myMap.containsKey(key)) { myMap.put(key, value); } return myMap.get(key); } }
92. Put if Absent public class MapExample<K, V> { Map<K, V> myMap = new ConcurrentHashMap<>(); public synchronized V addIfAbsent(K key, V value) { if (!myMap.containsKey(key)) { myMap.put(key, value); } return myMap.get(key); } } // Concurrent hash map is synchronised using another lock.
93. Put if Absent public class MapExample<K, V> { Map<K, V> myMap = new ConcurrentHashMap<>(); public synchronized V addIfAbsent(K key, V value) { synchronized (myMap) { if (!myMap.containsKey(key)) { myMap.put(key, value); } return myMap.get(key); } } } // Internal lock change and what if the lock is private
94. Put if Absent public class MapExample<K, V> { MyMap<K, V> myMap = new MyMap<>(new HashMap<>()); } class MyMap<K, V> implements Map<K, V> { @GuardedBy("lock") private Map<K, V> delegate; private Object lock = new Object(); public MyMap(Map<K, V> map) { delegate = map; } @Override public V put(K key, V value) { synchronized (lock) { delegate.put(key, value); } } public V addIfAbsent(K key, V value) { synchronized (lock) { if (!delegate.containsKey(key)) { delegate.put(key, value); } return delegate.get(key); } } }
95. Put if Absent public class MapExample<K, V> { MyMap<K, V> myMap = new MyMap<>(new HashMap<>()); } class MyMap<K, V> implements Map<K, V> { @GuardedBy("lock") private Map<K, V> delegate; private Object lock = new Object(); public MyMap(Map<K, V> map) { delegate = map; } @Override public V put(K key, V value) { synchronized (lock) { delegate.put(key, value); } } public V addIfAbsent(K key, V value) { synchronized (lock) { if (!delegate.containsKey(key)) { delegate.put(key, value); } return delegate.get(key); } } }
96. Put if Absent public class MapExample<K, V> { MyMap<K, V> myMap = new MyMap<>(new HashMap<>()); } class MyMap<K, V> implements Map<K, V> { @GuardedBy("lock") private Map<K, V> delegate; private Object lock = new Object(); public MyMap(Map<K, V> map) { delegate = map; } @Override public V put(K key, V value) { synchronized (lock) { delegate.put(key, value); } } public V addIfAbsent(K key, V value) { synchronized (lock) { if (!delegate.containsKey(key)) { delegate.put(key, value); } return delegate.get(key); } } }
97. Put if Absent public class MapExample<K, V> { MyMap<K, V> myMap = new MyMap<>(new HashMap<>()); } class MyMap<K, V> implements Map<K, V> { @GuardedBy("lock") private Map<K, V> delegate; private Object lock = new Object(); public MyMap(Map<K, V> map) { delegate = map; } @Override public V put(K key, V value) { synchronized (lock) { delegate.put(key, value); } } public V addIfAbsent(K key, V value) { synchronized (lock) { if (!delegate.containsKey(key)) { delegate.put(key, value); } return delegate.get(key); } } }
98. Put if Absent public class MapExample<K, V> { MyMap<K, V> myMap = new MyMap<>(new HashMap<>()); } class MyMap<K, V> implements Map<K, V> { @GuardedBy("lock") private Map<K, V> delegate; private Object lock = new Object(); public MyMap(Map<K, V> map) { delegate = map; } @Override public V put(K key, V value) { synchronized (lock) { delegate.put(key, value); } } public V addIfAbsent(K key, V value) { synchronized (lock) { if (!delegate.containsKey(key)) { delegate.put(key, value); } return delegate.get(key); } } }
99. Publishing public class Publishing { private HashMap<String, String> mutableMap = new HashMap<>(); private ImmutableHolder<String, String> immutableHolder = new ImmutableHolder(mutableMap); @NotThreadSafe public void update() { immutableHolder.getStringMap().put("junk", "junk"); } class ImmutableHolder<K, V> { private final Map<K, V> internalMap; ImmutableHolder(Map<K, V> internalMap) { this.internalMap = internalMap; } public Map<K, V> getStringMap() { return internalMap; } public synchronized void putValue(K key, V value) { internalMap.put(key, value); } } }
100. Publishing public class Publishing { private HashMap<String, String> mutableMap = new HashMap<>(); private ImmutableHolder<String, String> immutableHolder; @NotThreadSafe public void update() { immutableHolder.getStringMap().put("junk", "junk"); } class ImmutableHolder<K, V> { private final Map<K, V> internalMap; ImmutableHolder(Map<K, V> internalMap) { this.internalMap = internalMap; } public Map<K, V> getStringMap() { return internalMap; } public synchronized void putValue(K key, V value) { internalMap.put(key, value); } } }
101. Publishing public class Publishing { private HashMap<String, String> mutableMap = new HashMap<>(); private ImmutableHolder<String, String> immutableHolder; @NotThreadSafe public void update() { immutableHolder.getStringMap().put("junk", "junk"); } class ImmutableHolder<K, V> { private final Map<K, V> internalMap; ImmutableHolder(Map<K, V> internalMap) { this.internalMap = internalMap; } public Map<K, V> getStringMap() { return internalMap.clone(); } public synchronized void putValue(K key, V value) { internalMap.put(key, value); } } }
102. Publishing public class Publishing { private HashMap<String, String> mutableMap = new HashMap<>(); private ImmutableHolder<String, String> immutableHolder = new ImmutableHolder(mutableMap); @NotThreadSafe public void update() { mutableMap.put("junk", "junk"); } class ImmutableHolder<K, V> { private final Map<K, V> internalMap; ImmutableHolder(Map<K, V> internalMap) { this.internalMap = internalMap; } public Map<K, V> getStringMap() { return internalMap.clone(); } public synchronized void putValue(K key, V value) { internalMap.put(key, value); } } }
103. Publishing public class Publishing { private HashMap<String, String> mutableMap = new HashMap<>(); private ImmutableHolder<String, String> immutableHolder = new ImmutableHolder(mutableMap); @NotThreadSafe public void update() { mutableMap.put("junk", "junk"); } class ImmutableHolder<K, V> { private final Map<K, V> internalMap; ImmutableHolder(Map<K, V> internalMap) { this.internalMap = internalMap.clone(); } public Map<K, V> getStringMap() { return internalMap; } public synchronized void putValue(K key, V value) { internalMap.put(key, value); } } }
104. Publishing public class Publishing { private HashMap<String, String> mutableMap = new HashMap<>(); private ImmutableHolder<String, String> immutableHolder = new ImmutableHolder(mutableMap); @NotThreadSafe public void update() { mutableMap.put("junk", “junk”); // no effect immutableHolder.getStringMap().put("junk", “junk"); // Crash. } class ImmutableHolder<K, V> { private final Map<K, V> internalMap; ImmutableHolder(Map<K, V> internalMap) { this.internalMap = Collections.unmodifiableMap(internalMap); } public Map<K, V> getStringMap() { return internalMap.clone(); } } }
105. Publishing
106. Publishing • Immutable objects can be published anywhere.
107. Publishing • Immutable objects can be published anywhere. • Effectively immutable objects (mutable objects which we will not change) can be published using “safe publishing” - volatile, final, static initializer.
108. Publishing • Immutable objects can be published anywhere. • Effectively immutable objects (mutable objects which we will not change) can be published using “safe publishing” - volatile, final, static initializer. • Mutable variables must be synchronized
109. Annotations
110. Annotations • @ThreadSafe, @NotThreadSafe
111. Annotations • @ThreadSafe, @NotThreadSafe • @Immutable
112. Annotations • @ThreadSafe, @NotThreadSafe • @Immutable • @GuardedBy
113. Annotations • @ThreadSafe, @NotThreadSafe • @Immutable • @GuardedBy • @GuardedBy(“this”)
114. Annotations • @ThreadSafe, @NotThreadSafe • @Immutable • @GuardedBy • @GuardedBy(“this”) • @GuardedBy(“fieldName”)
115. Annotations • @ThreadSafe, @NotThreadSafe • @Immutable • @GuardedBy • @GuardedBy(“this”) • @GuardedBy(“fieldName”) • @GuardedBy(“methodName()”)
116. Annotations • @ThreadSafe, @NotThreadSafe • @Immutable • @GuardedBy • @GuardedBy(“this”) • @GuardedBy(“fieldName”) • @GuardedBy(“methodName()”) • @MainThread, @WorkerThread
117. Summary • Encapsulation is your best friend. • Document thread safety. • Use composition to extend a synchronised class. • Use immutable variables. • Don’t let constructor escape this • Publication: • Immutable objects can be published anywhere • Effectively immutable objects can be safely published. • Mutable object needs to be kept behind a lock.
118. TODO • Java concurrency in Practice - Chapter 2-5, Chapter 13, 15, and 16. • Devoxx talk on concurrency. • Write code yourself? • How to test concurrency? - JCStress
120. Questions??