Concurrency in Object Oriented

Transcription

1 Concurrency in Object Oriented Programs 5 Object-Oriented Software Development COMP4001 CSE UNSW Sydney Lecturer: John Potter 1

2 Outline Deadlocks Dining Philosophers Lock Ordering Reducing Lock Granularity Open calls Use of polling and timeouts Atomic acquisition of multiple locks Semaphores Lock Striping 2

3 Deadlocks Livenessis a concurrent application's ability to execute in a timely manner tension between safety and liveness Deadlock occurs in a program when all its constituent threads are blocked each thread was blocked waiting for a resource held by the other Java applications do not recover from deadlock 3

4 Four Conditions for Deadlock ref Coffman, Elphick and Shoshani(1971) Serially reusable resources a resource is either assigned to one thread or it is available No preemption only a thread holding a resource may release it Incremental acquisition threads already holding resources may request new resources Wait-for cycle two or more threads form a circular chain 4

5 Preventing Deadlock Removing mutual exclusion no thread may have exclusive access to a resource but then it is difficult to maintain safety See non-blocking synchronization algorithms Allow preemption In Java, applications need to repeatedly check for interrupted status Can be difficult to maintain consistent state Remove incremental acquisition a thread acquires all the resources it will need in one hit Avoid circular wait use a partial order on resources e.g. memory addresss/ object hashcodes manage resources hierarchically Last 2 points will be considered in these slides 5

6 Dining Philosophers Problem Dijkstra, 1968 Five philosophers sit around a circular table. Each philosopher spends his life alternately thinking and eating. In the centre of the table is a large bowl of spaghetti. A philosopher needs two forks to eat a helping of spaghetti One fork is placed between each pair of philosophers and they agree to only use the fork to his immediate right and left

7 Dining Philosophers Problem A demonstration of deadlock 7

8 A Trivial Deadlock Example public class LeftRightDeadlock{ private final Object left = new Object(); private final Object right = new Object(); public void leftright() { synchronized (left){ synchronized (right){ dosomething(); public void rightleft() { synchronized (right){ synchronized (left){ dosomethingelse(); 8

9 A Trivial Deadlock Example Unlucky Timing in LeftRightDeadlock A program will be free of deadlocks if all threads acquire the locks they need in a fixed global order 9

10 DeadlockProne? public void transfermoney(account fromaccount, Account toaccount, DollarAmountamount) throws InsufficientFundsException{ synchronized (fromaccount){ synchronized (toaccount){ if (fromaccount.getbalance().compareto(amount) < 0) else { fromaccount.debit(amount); toaccount.credit(amount); throw new InsufficientFundsException(); Safety from race conditions requires some form of locking on both accounts, as shown, so that transfer will not result in funds being lost 10

11 Dynamic Lock-Ordering Deadlock public void transfermoney(account fromaccount, Account toaccount, DollarAmountamount) throws InsufficientFundsException{ synchronized (fromaccount){ synchronized (toaccount){ if (fromaccount.getbalance().compareto(amount) < 0) else { fromaccount.debit(amount); toaccount.credit(amount); throw new InsufficientFundsException(); Deadlock can arise from concurrent calls: transfermoney(myaccount, youraccount, 10); transfermoney(youraccount, myaccount, 20); 11

12 Deadlocks in Java The JVM is not very helpful in resolving deadlocks When a set of Java threads deadlock, that's the end of the game Deadlocks rarely manifest themselves immediately The fact that a class has a potential deadlock doesn't mean that it ever will deadlock Avoiding deadlocks is hard in Java! 12

13 Avoiding Deadlocks The hardest problem in concurrent programming A program will be free of deadlocks if all threads acquire the locks in a fixed global order asymmetry (Dining Philosophers Problem) can use hash code value to order locks Deadlock may be caused by coarse-grained locking shrink synchronized methods to synchronized blocks to guard ONLY operations that involve shared state Polled and timed lock attempts See Lock interface in Java 5 acquisition of locks may be interrupted 13

14 Outline Deadlocks Dining Philosophers Lock Ordering Reducing Lock Granularity Open calls Use of polling and timeouts Atomic acquisition of multiple locks Semaphores Lock Striping 14

15 Dining Philosophers Problem Each fork is a shared resource with actions get and put. FORK left phil[1]: PHIL right phil[0]: PHIL left FORK right phil[4]: PHIL When hungry, each PHIL must first get his right and left forks before he can start eating right left FORK phil[2]: PHIL right FORK left left FORK right phil[3]: PHIL 15

16 Dining Philosophers Problem class Fork { private boolean taken=false; final int identity; public Fork (int i) { identity = i; synchronized void put() { taken=false; notify(); synchronized void get() throws java.lang.interruptedexception { while (taken) wait(); taken=true; 16

17 Dining Philosophers Problem public class Philosopher extends Thread { final int identity; final Fork left; final Fork right; public Philosoper (int identity, Fork left, Fork right) { this.identity = identity; this.left = left; this.right = public void run() { // see next slide 17

18 Dining Philosophers Problem public void run() { try { while (true) { sleep(thinktime); right.get(); left.get(); sleep(eattime); // thinking // hungry // got right fork // got left fork // eating right.put(); left.put(); catch (java.lang.interruptedexception e){ 18

19 Dining Philosophers Problem Code to create the philosopher threads and fork monitors: for (int i =0; i<n; ++i) { fork[i] = new Fork(i); for (int i =0; i<n; ++i) { phil[i] = new Philosopher (i, fork [i],fork [(i+1)%n]); phil[i].start(); 19

20 Solving The Philosophers Problem Deadlock can be avoided by ensuring that a wait-for cycle cannot exist. but how? Introduce an asymmetryinto our definition of philosophers Use the identity of a philosopher to make even numbered philosophers get their left forks first Odd numbered philosophers get their right forks first 20

21 Solving The Philosophers Problem public void run() { try { while (true) { sleep(thinktime); // thinking // hungry if (identity%2 == 0) { left.get(); right.get(); else { right.get(); left.get(); // got forks sleep(eattime); // eating right.put(); left.put(); catch (java.lang.interruptedexception e){ No wait-for cycle is possible! Cycle is broken because of reversal of order of acquisition by odd Philosophers Philosophers respect a protocol for lock acquisition 21

22 SolvingThe Philosophers Problem There are other solutions to the problem A simpler variation is just to break the cycle that causes the potential deadlock in just one place All Philosophers acquire forks in left right order, except for one e.g. the last one In effect, this places on order on the forks i< j implies Fork[i] < Fork [j] With an acquisition protocol that lower ordered forks must be acquired first So the last Philosopher[N-1] must acquire her right Fork [0] before the left Fork [N-1] Any other Philosopher[i] acquires left Fork[i] before right Fork [i+1] 22

23 Outline Deadlocks Dining Philosophers Lock Ordering Reducing Lock Granularity Open calls Use of polling and timeouts Atomic acquisition of multiple locks Semaphores Lock Striping 23

24 Recall Lock-Ordering Deadlock public void transfermoney(account fromaccount, Account toaccount, DollarAmountamount) throws InsufficientFundsException{ synchronized (fromaccount){ synchronized (toaccount){ if (fromaccount.getbalance().compareto(amount) < 0) else { fromaccount.debit(amount); toaccount.credit(amount); throw new InsufficientFundsException(); transfermoney(myaccount, youraccount, 10); transfermoney(youraccount, myaccount, 20); 24

25 Ensuring Lock-Ordering The order of arguments cannot be controlled within the definition of the transfer method To avoid deadlock, we can impose a global ordering on locks In Java use object identity Or rather, it s hashcode: System.identityHashCode(Object o) BUT occasionally different objects will have the same hashcode So handle that case specially 25

26 Ensuring Lock-Ordering public void transfermoney(account fromacct, Account toacct, DollarAmount amount) throws InsufficientFundsException{ int fromhash = System.identityHashCode(fromAcct); inttohash= System.identityHashCode(toAcct); if (fromhash< tohash) { synchronized (fromacct){ synchronized (toacct){/* do transfer */ else { synchronized (toacct){ synchronized (fromacct){/* do transfer */ This orders lock acquisition according to the hash of the locks object identity. This imposes a global ordering on all locks (except when they have the same hash) 26

27 Ensuring Lock-Ordering private static final Object tielock = new Object(); public void transfermoney(account fromacct, Account toacct, DollarAmount amount) throws InsufficientFundsException{ int fromhash = System.identityHashCode(fromAcct); inttohash= System.identityHashCode(toAcct); if (fromhash< tohash) { synchronized (fromacct) { synchronized (toacct){/* do transfer */ else if (fromhash> tohash) { synchronized (toacct){ synchronized (fromacct) {/* do transfer */ else { synchronized (tielock){ synchronized (fromacct) { synchronized (toacct){/* do transfer */ Use a single extra lock to deal with tied hashcodes. This ensures that both account locks can only be acquired by a single thread. It will rarely be used, so should not be a concurrency bottle-neck. 27

28 Outline Deadlocks Dining Philosophers Lock Ordering Reducing Lock Granularity Open calls Use of polling and timeouts Atomic acquisition of multiple locks Semaphores Lock Striping 28

29 Lock-Ordering Between Objects class Taxi { private Point location, destination; private final Dispatcher dispatcher; public synchronized Point getlocation() { return location; Could this be deadlocked? public synchronized void setlocation(point location) { this.location= location; if (location.equals(destination)) dispatcher.notifyavailable(this); The method call to dispatcher is an example of using an alienmethod. Such calls may be prone to deadlock when made within synchronized blocks. 29

30 Lock-Ordering Between Objects class Taxi { private Point location, destination; private final Dispatcher dispatcher; public synchronized Point getlocation(){ return location; class Dispatcher { private final Set<Taxi> taxis; private final Set<Taxi> availabletaxis; public synchronized void notifyavailable(taxi taxi) { availabletaxis.add(taxi); public synchronized void setlocation(point location) { this.location= location; if (location.equals(destination)) dispatcher.notifyavailable(this); public synchronized Image getimage(){ Image image= new Image(); for (Taxi t : taxis) image.drawmarker(t.getlocation()); return image; In Taxi, setlocation acquires its implicit (Taxi instance) lock, then dispatcher lock. In Dispatcher, getimage acquires its own lock, then that of its taxis. Potential DEADLOCK!, even though there is no direct cycle of calls. The problem is that different threads can request locks in different orders. 30

31 Open Calls Calling a method with no locks held is called an open call Classes that rely on open calls are better behaved and easier to use correctly than classes that make calls with locks held The Taxi-Dispatcher problem can be fixed by making the Dispatcher calls to Taxi open In effect we reduce the granularity or scope of the lock to avoid Taking care to maintain consistent behaviour 31

32 AvoidingDeadlock with Open Calls class Taxi { private Point location, destination; private final Dispatcher dispatcher;... public synchronizedvoid setlocation(point location) { this.location= location; if (location.equals(destination)) dispatcher.notifyavailable(this); BAD! class Taxi { private Point location, destination; private final Dispatcher dispatcher; public void setlocation(point location){ booleanreacheddestination; synchronized (this){ this.location= location; reacheddestination= location.equals(destination); if (reacheddestination) dispatcher.notifyavailable(this); GOOD! Call to dispatcher is open 32

33 Avoiding Deadlock with Open Calls class Dispatcher { private final Set<Taxi> taxis; private final Set<Taxi> availabletaxis; public synchronizedimage getimage(){ Image image= new Image(); for (Taxi t : taxis) image.drawmarker(t.getlocation()); return image; Note use of snapshot copy to allow scope of implicit lock to be limited BAD! class Dispatcher { private final Set<Taxi> taxis; private final Set<Taxi> availabletaxis; public Image getimage(){ Set<Taxi> copy; synchronized (this){ copy = new HashSet<Taxi>(taxis); Image image= new Image(); for (Taxi t : copy) image.drawmarker(t.getlocation()); return image; GOOD! Call to taxis t are open 33

34 Outline Deadlocks Dining Philosophers Lock Ordering Reducing Lock Granularity Open calls Use of polling and timeouts Atomic acquisition of multiple locks Semaphores Lock Striping 34

35 One-HitAcquisition of Multiple Locks Lock ordering is one approach to avoiding deadlock with code using multiple locks Another is the use of open calls Reducing scope / granularity of locks Another approach is to acquire multiple locks in an atomic action Attempt may succeed or fail If it fails, then any acquired locks must be released May then try again, possibly after a delay Can use polling or timeout to acquire locks 35

36 The Java locks package The java.util.concurrent.locks package since Java 5 Provide a framework for locking and waiting for conditions distinct from built-in synchronization and monitors. Interfaces: Lock, ReadWriteLock, Condition Classes: ReentrantLock, ReentrantReadWriteLock, ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock, LockSupport, AbstractQueuedSynchronizer 36

37 Intrinsic Locks vslock Objects Intrinsic locks it is not possible to interrupt a thread waiting to acquire a lock locks are acquired and released automatically must be acquired and released in the same block of code Lock objects offer a choice of unconditional, polled, timed, and interruptible lock acquisition all lock and unlock operations are explicit make non-block structured locking disciplines impossible 37

38 The Lock Interface Define abstract locking operations all lock and unlock operations are explicit All Lock implementations mustenforce the same memory synchronization semantics May use different locking acquisition unconditional, polled, timed, and interruptible public interface Lock { void lock(); void unlock(); booleantrylock();... 38

39 The ReentrantLockClass An implementation of the Lock interface A mutual exclusion lock similar to built-in locks Lock lock = new ReentrantLock(); lock.lock(); try { // update object state, and restore invariants if necessary finally { lock.unlock(); Always immediately follow lock() with a try/finally 39

40 The trylock() Method Used for polling a lock Always return immediately return false if lock is not available Lock lock= new ReentrantLock(); if (lock.trylock()) { try { // manipulate protected state finally { lock.unlock(); else { // perform alternative actions 40

41 Avoiding Deadlock with trylock() public class Friend { public synchronizedvoid bow(friend bower) { bower.bowback(this); public synchronizedvoid bowback(friend bower) { What can go wrong? Friend peter = new Friend(); Friend george = new Friend(); new Thread(new Runnable() { public void run() { peter.bow(george); ).start(); new Thread(new Runnable() { public void run() { george.bow(peter); ).start(); 41

42 Avoiding Deadlock with trylock() public class Friend { private final Lock lock= new ReentrantLock(); public void bow(friend bower) { if (impendingbow(bower)) { try { bower.bowback(this); finally { lock.unlock(); bower.lock.unlock(); Other code is not changed public booleanimpendingbow(friend bower) { Boolean mylock = false; Boolean yourlock = false; try { mylock = lock.trylock(); yourlock = bower.lock.trylock(); finally { if (!(mylock&& yourlock)) { if (mylock) lock.unlock(); if (yourlock) bower.lock.unlock(); return mylock&& yourlock; 42

43 Avoiding Deadlock with trylock() public class Friend { private final Lock lock= new ReentrantLock(); public void bow(friend bower) { if (impendingbow(bower)) { try { bower.bowback(this); finally { lock.unlock(); bower.lock.unlock(); Other code is not changed public booleanimpendingbow(friend bower) { Boolean mylock = false; Boolean yourlock = false; try { mylock = lock.trylock(); yourlock = bower.lock.trylock(); finally { if (!(mylock&& yourlock)) { if (mylock) lock.unlock(); if (yourlock) bower.lock.unlock(); return mylock&& yourlock; 43

44 Outline Deadlocks Dining Philosophers Lock Ordering Reducing Lock Granularity Open calls Use of polling and timeouts Atomic acquisition of multiple locks Semaphores Lock Striping 44

45 Semaphores The classic method for restricting access to shared resources by Edsger Dijkstra to prevent race conditions in the dining philosophers problem they do NOT prevent deadlocks A counting semaphore controls the number of activities that can access a certain resource A binary semaphore is a locked/unlocked flag of a single resource. i.e. mutual exclusion 45

46 Semaphores in Java 5 java.util.concurrent.semaphore Java semaphores manage a set of virtual permits Activities can acquire permits if no permit is available, they block until one is (or interrupted) Activities release permits when they are done with them 46

47 Semaphores in Java 5 The initial number of permits is given to the constructor A binary semaphore has a sole permit similar to Java locks, but does not support reentrant locking The initial number of permits may be zero or negative in such case, releases must occur before any acquires will be granted Correct usage of a semaphore is established by programming convention in the application 47

48 A Semaphore Example public class BoundedHashSet{ private final Set set; private final Semaphore sema; public BoundedHashSet(intbound){ this.set= Collections.synchronizedSet( new HashSet()); sema= new Semaphore(bound); public booleanremove(object o) { booleanwasremoved= set.remove(o); if (wasremoved) sema.release(); return wasremoved; public booleanadd(object o) throws InterruptedException{ sema.acquire(); booleanwasadded= false; try { wasadded= set.add(o); return wasadded; finally { if (!wasadded) sema.release(); 48

49 A Semaphore Example public class BoundedHashSet{ private final Set set; private final Semaphore sema; public BoundedHashSet(intbound){ this.set= Collections.synchronizedSet( new HashSet()); sema= new Semaphore(bound); public booleanremove(object o) { booleanwasremoved= set.remove(o); if (wasremoved) sema.release(); return wasremoved; public booleanadd(object o) throws InterruptedException{ sema.acquire(); booleanwasadded= false; try { wasadded= set.add(o); return wasadded; finally { if (!wasadded) sema.release(); 49

50 Implementing Resource Pools Semaphores are useful for implementing resource pools e.g. database connection pools Initialise a Semaphore to the pool size Acquire a permit before trying to fetch a resource from the pool acquire blocks until the pool becomes nonempty Release the permit after putting a resource back in the pool 50

51 Outline Deadlocks Dining Philosophers Lock Ordering Reducing Lock Granularity Open calls Use of polling and timeouts Atomic acquisition of multiple locks Semaphores Lock Striping 51

52 Lock Striping Finer-grained locks used especially for arraybased data structures Each part of the (array) data is protected by a separate lock Different parts may be accessed concurrently This is essentially a form of (internal) lock splitting ConcurrentHashMap provides a good example Avoids global data e.g. size is estimated by summing over each separate (protected) part 52

53 Lock Striping Example public class StripedMap{ // Synchronization policy: buckets[n] // guarded by locks[n%n_locks] private static final int N_LOCKS = 16; private final Node[] buckets; private final Object[] locks; public StripedMap(int numbuckets) { buckets = new Node[numBuckets]; locks = new Object[N_LOCKS]; for (inti= 0; i< N_LOCKS; i++) locks[i] = new Object(); private static class Node { Node next; Object key; Object value; private final int hash(object key) { return Math.abs(key.hashCode() % buckets.length); 2010 John Potter and Yi Lu CSE UNSW Sydney 53

54 Lock Striping Example public Object get(object key) { int i= hash(key); synchronized (locks[i% N_LOCKS]) { for (Node m = buckets[hash]; m!= null; m = m.next) if (m.key.equals(key)) return m.value; return null; public void clear() { for (inti= 0; i< buckets.length; i++) { synchronized (locks[i% N_LOCKS]){ buckets[i] = null; 2010 John Potter and Yi Lu CSE UNSW Sydney 54