Concurrency API. Bram Inniger October 25, Based on previous work by Pavel Grigorenko and Rein Raudjärv

Transcription

1 Concurrency API Bram Inniger October 25, 2016 Based on previous work by Pavel Grigorenko and Rein Raudjärv

2 Agenda (Old) Synchronised Collections Concurrent Collections Synchronisers

3 Thread Safety A piece of code is thread-safe if it manipulates shared data structures only in a manner that guarantees safe execution by multiple threads at the same time.

4 (Old) Synchronised Collections

5 Java 1.0 java.util.vector java.util.hashtable Internally synchronised, and sync is not optional

6 Java 1.2 java.util.arraylist java.util.linkedlist java.util.hashmap java.util.treemap Not thread safe, must synchronise externally

7 java.util.collections Use synchronised polymorphic wrappers: Collections.sychronized[List Map Set ] (Conditionally) Thread safe

8 Compound Actions (1) public static Object getlast(vector list) { int lastindex = list.size() - 1; return list.get(lastindex); public static void deletelast(vector list) { int lastindex = list.size() - 1; list.remove(lastindex);

9 Compound Actions (2) Interleaving of getlast() and deletelast() throws ArrayIndexOutOfBoundsException

10 Compound Actions: Client-side Locking public static Object getlast(vector list) { synchronized (list) { int lastindex = list.size() - 1; return list.get(lastindex); public static void deletelast(vector list) { synchronized (list) { int lastindex = list.size() - 1; list.remove(lastindex);

11 Iteration: Naively for (int i = 0; i < vector.size(); i++) { dosomething(vector.get(i)); This may throw ArrayIndexOutOfBoundsException

12 Iteration: Client-side Locking synchronized (vector) { for (int i = 0; i < vector.size(); i++) { dosomething(vector.get(i));

13 Iteration that may throw ConcurrentModificationException Iterator it = vector.iterator(); while (it.hasnext()) { dosomething(it.next()); Iterators returned by the synchronised collections are Fail-fast.

14 Beware of hidden Iterators Is this safe? for (Widget w : widgetlist) { dosomething(w); Or maybe this? System.out.println("Widgets: " + widgetlist);

15 Synchronise iterations Iteration requires explicit synchronisation: Set s = Collections.syn Set(new HashSet()); synchronized(s) { for (Iterator i = s.iterator(); i.hasnext(); ) { dosomething(i.next()); Use-case: Event Listeners Inefficient > make a copy!

16 Copy On Read (1) for (Iterator it = new ArrayList(vector).iterator(); it.hasnext(); ) { dosomething(it.next()); The constructor may throw ArrayIndexOutOfBoundsException or ConcurrentModificationException.

17 Copy On Read (2) for (Iterator it = Arrays.asList(vector.toArray()).iterator(); it.hasnext(); ) { dosomething(it.next()); Finally: Thread safe! (please don t use it though)

18 Performance The synchronised collections: Serialised access > not efficient Only one thread at once (thread contention) Reads, writes, iterations all use a single lock

19 Concurrent Collections

20 JSR166: Concurrency Utilities Chaired by prof. Doug Lea (State University of New York at Oswego) index.html

21 Concurrent Collections (Java 5) java.util.concurrent package: ConcurrentHashMap CopyOnWriteArrayList CopyOnWriteArraySet Designed for multiple threads More efficient Replaces synchronised HashMap, ArrayList and LinkedHashSet

22 ConcurrentHashMap Finer-grained locking mechanism: lock striping Multiple write locks, arbitrary many reads

23 Additional Atomic Map Operations interface ConcurrentMap<K,V> extends Map<K,V> { V putifabsent(k key, V value); boolean remove(k key, V value); boolean replace(k key, V oldval, V newval); V replace(k key, V newvalue); No need for client side locking!

24 putifabsent(key, value) if (map.containskey(key)) { return map.get(key); else { return map.put(key, value);

25 remove(key, value) if (map.containskey(key) && map.get(key).equals(value)) { map.remove(key); return true; else { return false;

26 replace(key, oldval, newval) if (map.containskey(key) && map.get(key).equals(oldval)) { map.put(key, newval); return true; else { return false;

27 Compare and Set ConcurrentMap<Object, Integer> counthits = new ConcurrentHashMap<>(); private void incrementcount(object key) { Integer oldval, newval; do { oldval = counthits.get(key); newval = (oldval==null)? 1: (oldval + 1); while (!counthits.replace(key, oldval, newval));

28 Atomic Primitives AtomicBoolean AtomicInteger AtomicLong AtomicReference<V>

29 AtomicInteger (1) class Counter { private int c = 0; public void increment() { c++; public void decrement() { c--; public int value() { return c; Fine in a single thread, not so much multi-threaded

30 AtomicInteger (2) class Counter { private volatile int c = 0; public void increment() { c++; public void decrement() { c--; public int value() { return c; If you do this, I will look up your contact info, find your next of kin, and personally tell them how disappointed I am in you.

31 AtomicInteger (3) class SynchronizedCounter { private int c = 0; public synchronized void increment() { c++; public synchronized void decrement() { c--; public synchronized int value() { return c; Does the job, but gets trickier for less trivial code

32 AtomicInteger (4) import java.util.concurrent.atomic.atomicinteger; class AtomicCounter { private AtomicInteger c = new AtomicInteger(0); public void increment() { c.incrementandget(); public void decrement() { c.decrementandget(); public int value() { return c.get();

33 Thread Safe Iteration ConcurrentMap<Object, Object> chm = new ConcurrentHashMap<>(); for (Iterator it = chm.iterator(); it.hasnext(); ) { dosomething(it.next()); Iterators are weakly consistent: No ConcurrentModificationException is thrown Modifications and removals are visible Insertions may be visible, no guarantees

34 Performance The Concurrent collections: Parallel access > more efficient But: size() may be either not atomic, or not correct

35 CopyOnWriteArray[List Set] Use when: Care most about traversing the Collection Don t care about temp inconsistency putifabsent() sequentially scans the array Iterator.remove() not supported! Creates "snapshot" at Iterator creation

36 Queue Idea: list without random access, add in back, take from front LinkedList, basic implementation PriorityQueue, allow assigning priorities ConcurrentLinkedQueue, thread-safe, lockfree, does not block

37 Blocking Queue Wait until an item can be taken / free space appears, thread safe! Consumer-Producer ArrayBlockingQueue (bounded, FIFO) LinkedBlockingQueue (optionally bounded) SynchronousQueue (zero capacity) PriorityBlockingQueue (unbounded, priority)

38 Interruptible Methods E take() throws InterruptedException Blocking method How do stop waiting? Can be interrupted with Thread.interrupt() Only thread-owner should ever call this

39 Handling Calling Interruptible Method Propagate the InterruptedException Restore the interrupt: try { processtask(queue.take()); catch (InterruptedException e) { // Restore interrupted status! Thread.currentThread().interrupt();

40 Non-cancelable tasks public Task getnexttask(blockingqueue<task> queue) { boolean interrupted = false; try { while (true) { try { return queue.take(); catch (InterruptedException e) { interrupted = true; // fall through and retry finally { if (interrupted) Thread.currentThread().interrupt();

41 TimeUnit Convenient time conversions: TimeUnit.MILLISECONDS.convert(20L, TimeUnit.SECONDS); TimeUnit.SECONDS.toMillis(20L); Collections with timeouts: queue.offer(task,100l, TimeUnit.NANOSECONDS); Thread.sleep: TimeUnit.SECONDS.sleep(10L);

42 Concurrent Collections (Java 6) Interface ConcurrentNavigableMap: ConcurrentSkipListMap ConcurrentSkipListSet Replacements for respectively: Synchronised TreeMap Synchronised TreeSet

43 Deques Efficient insertion and removal from both the head and the tail Not thread safe basic implementations: LinkedList ArrayDeque

44 Blocking Deques LinkedBlockingDeque Thread safe Blocks Work stealing pattern

45 Concurrent Collections (Java 7) ConcurrentLinkedDeque Improved ConcurrentLinkedQueue Interface TransferQueue LinkedTransferQueue

46 TransferQueue interface TransferQueue<E> extends BlockingQueue<E> { boolean trytransfer(e e) void transfer(e e) throws InterruptedException boolean haswaitingconsumer() int getwaitingconsumercount()...

47 Synchronisers

48 Synchroniser is any object that coordinates the control flow of threads based on its state. Decide if an incoming thread can pass or has to wait.

49 Latch is a synchroniser that can delay the progress of threads until it reaches its terminal state. Acts as a gate, and remains open, once opened. Usages: Game lobby, waiting for all players to join Dependant services startup Resources initialisation

50 CountDownLatch class CountDownLatch { CountDownLatch(int count); void await(); void await(long timeout, TimeUnit unit); void countdown(); long getcount(); General idea: every incoming thread calls countdown(), then await(), until count is reached.

51 FutureTask class FutureTask<V> implements Future<V> { FutureTask(Callable<V> callable) FutureTask(Runnable r, V result) void run() V get()... interface Callable<V> { V call() Three states: waiting, running, done. Done is final again.

52 CompletableFuture (Java 8) class CompletableFuture<V> implements Future<V> { CompletableFuture<V> supplyasync(supplier<v> supplier) CompletableFuture<V> thenapply(function<? super T,? extends U> fn) CompletableFuture<Void> thenaccept( Consumer<? super T> action) boolean complete(t value) CompletableFuture<T> exceptionally(function<throwable,? extends T> fn)

53 CompletableFuture Chaining CompletableFuture.supplyAsync(this::findReceiver).thenApply(this::sendMsg).exceptionally(ex->new Result(Status.FAILED)).thenAccept(this::notify);

54 Semaphore (1) Counting semaphores are used to control the number of activities that can access a certain resource or perform a given action at the same time. Great to implement resource pools (e.g. database connectors). Can make any collection both blocking and bounded.

55 Semaphore (2) class Semaphore { Semaphore(int permits) void acquire() void release()... acquire() takes permit or blocks release() returns permit Basically, more flexible Lock

56 Barrier is a synchroniser that can delay the progress of threads until all parties have arrived. Generally: a Latch waits for events, a Barrier for threads.

57 CyclicBarrier class CyclicBarrier { CyclicBarrier(int parties) int await()... General idea: every incoming thread calls await(), when the nr of parties is reached, all threads are unblocked, and receive their arrival index. Usable multiple times (cyclic)

58 Taxonomy High level concurrency abstractions java.util.concurrent Low level locking synchronised blocks & java.util.concurrent.locks Low level primitives volatile, java.util.concurrent.atomic Data races: deliberate under-synchronisation Don t try it at home!

59 Summary Use concurrent collections over synchronised Use synchronisers instead of implementing your own low-level synchronisation Do not confuse: synchronised vs synchroniser

60 Recommended reading Java Concurrency in Practice, Brian Goetz

61 Homework assignment Implement a brute-force password cracker All details and code here: JavaFundamentalsZT/jf-hw-password-cracker When in doubt / have questions: jf@zeroturnaround.com Please note: you are all students at the highest educational institute of Estonia, act like it. If something is not 100% covered in the class, then do your own research!

62

63 Scalable Cache example public interface Computable<A, V> { V compute(a arg) throws InterruptedException; public class ExpensiveFunction implements Computable<String, BigInteger> { public BigInteger compute(string arg) { // after deep thought... return new BigInteger(arg);

64 public class Memoizer1<A, V> implements Computable<A, V> private final Map<A, V> cache = new HashMap<A, V>(); private final Computable<A, V> c; public Memoizer1(Computable<A, V> c) { this.c = c; public synchronized V compute(a arg) throws InterruptedException { V result = cache.get(arg); if (result == null) { result = c.compute(arg); cache.put(arg, result); return result;

65 Poor concurrency

66 public class Memoizer2<A, V> implements Computable<A, V> { private final Map<A, V> cache = new ConcurrentHashMap<A, V>(); private final Computable<A, V> c; public Memoizer2(Computable<A, V> c) { this.c = c; public V compute(a arg) throws InterruptedException { V result = cache.get(arg); if (result == null) { result = c.compute(arg); cache.put(arg, result); return result;

67 Computing duplicates

68 public class Memoizer3<A, V> implements Computable<A, V> {... public V compute(final A arg) throws InterruptedException { Future<V> f = cache.get(arg); if (f == null) { Callable<V> eval = new Callable<V>() { public V call() throws InterruptedException { return c.compute(arg); ; FutureTask<V> ft = new FutureTask<V>(eval); f = ft; cache.put(arg, ft); ft.run(); // call to c.compute happens here try { return f.get(); catch (ExecutionException e) { throw launderthrowable(e.getcause());

69 Still computing duplicates...

70 public V compute(final A arg) throws InterruptedException { while (true) { Future<V> f = cache.get(arg); if (f == null) { Callable<V> eval = new Callable<V>() {...; FutureTask<V> ft = new FutureTask<V>(eval); f = cache.putifabsent(arg, ft); if (f == null) { f = ft; ft.run(); try { return f.get(); catch (CancellationException e) { cache.remove(arg, f); catch (ExecutionException e) { throw launderthrowable(e.getcause());