1. CSE 501N Fall ‘09 23: Advanced Multithreading: Synchronization and Thread-Safety December 1, 2009 Nick Leidenfrost

2. 2 Lecture Outline The Last Lecture!  No new information after this  No more listening to me talk!*  *Does not include semester review  *…Or me showing up at your house randomly and start talking about Java  *Seriously, what’s your address? Continue with multi-threading  Quick Recap  How to prevent race conditions

3. 3 Recap Threads  Create a parallel chain of execution  Can create a thread by subclassing java.lang.Thread and overriding the run method  Call start on your class Runnable objects  Have your class implement java.lang.Runnable  Define the run method, pass Runnable into a new Thread  Call start on the Thread Race conditions  When two Threads want to use a resource at the same time, the state of the resource may be compromised  Note, the resource must be an instance variable, as each Thread gets its own copy of local variables

4. 4 The synchronized keyword Can declare methods to be synchronized When a method is synchronized :  The method itself executes atomically Only one thread can be in any synchronized method on an object at once  All other method calls on the object are held  Have to be careful about synchronization Quick and easy way to prevent race conditions, but… Can more easily cause deadlocks public synchronized void deposit (double amount) { //... }

5. 5 The synchronized keyword We can also declare synchronized blocks Synchronized blocks have to be given an object to synchronize on public void deposit (double amount) { synchronized (this) { //... Critical section }

6. 6 synchronized The Downside Because the synchronized block is a syntactical construct, it is relatively inflexible  Critical sections must be contained within a block statement  An application may need more selective control over locking and unlocking resources In the control-flow of a downstream method Conditional locking / unlocking

7. 7 Deadlocks A deadlock occurs if no thread can proceed because each thread is waiting for another to do some work first Your program may stall completely, or some element of functionality (controled by the deadlocked thread) may become unresponsive

8. 8 Locks More flexible methods of Mutual Exclusion Aside from the synchronized keyword, we can also provide mutually exclusive access to a critical section with lock objects Several types of these objects are available in the package java.util.concurrent.locks We will focus on the ReentrantLock  Allows a Thread to reacquire a lock that it already owns Other types of locks: ReadWriteLock

9. 9 Synchronizing Resource Access Typically, a lock object is added to a class whose methods access shared resources, like this: public class BankAccount { private double balance; private Lock balanceChangeLock; public BankAccount() { balanceChangeLock = new ReentrantLock();... }... }

10. 10 Synchronizing Resource Access Code that manipulates shared resource is surrounded by calls to lock and unlock : public void deposit (double amount) { balanceChangeLock.lock(); // Code that manipulates the shared resource balanceChangeLock.unlock(); }

11. 11 Synchronizing Resource Access When a thread calls lock, it “owns” the lock until the thread calls unlock Any thread that calls lock while another thread owns the lock is temporarily deactivated  The lock method blocks if the lock is already owned by another thread Thread scheduler periodically reactivates thread so it can try to acquire the lock Eventually, waiting thread can acquire the lock

12. 12 Synchronizing Resource Access Because calling lock causes other threads to block until they acquire the lock, it is very important to make sure the lock is properly released If code between calls to lock and unlock throws an exception, call to unlock never happens To overcome this problem, place call to unlock into a finally clause:

13. 13 Synchronizing Resource Access with Locks public void deposit(double amount) { balanceChangeLock.lock(); try { System.out.print("Depositing " + amount); double newBalance = balance + amount; System.out.println(", new balance is " + newBalance); balance = newBalance; } finally { balanceChangeLock.unlock(); } }

14. 14 Visualizing Object Locks

15. 15 Avoiding Deadlocks public void withdraw(double amount) { balanceChangeLock.lock(); try { while (balance < amount) Wait for the balance to grow... } finally { balanceChangeLock.unlock(); } } BankAccount example

16. 16 Avoiding Deadlocks How can we wait for the balance to grow? We can't simply call sleep inside withdraw method; thread will block all other threads that want to use balanceChangeLock In particular, no other thread can successfully execute deposit

17. 17 Avoiding Deadlocks Other threads will call deposit, but will be blocked until withdraw exits But withdraw doesn't exit until it has funds available DEADLOCK

18. 18 Condition Objects To overcome problem, use a Condition object  (also contained in package java.util.concurrent.locks ) Condition objects allow a thread to temporarily release a Lock, and to regain the Lock at a later time Each Condition object belongs to a specific Lock object

19. 19 Condition Objects You obtain a condition object with newCondition method of Lock interface public class BankAccount { private Lock balanceChangeLock; private Condition sufficientFundsCondition; public BankAccount() { balanceChangeLock = new ReentrantLock(); sufficientFundsCondition = balanceChangeLock.newCondition();... }... }

20. 20 Condition Objects It is customary to give the condition object a name that describes condition to test You need to implement an appropriate test to see if lock can be released As long as test is not fulfilled, call await on the condition object:

21. 21 Condition Objects public void withdraw(double amount) { balanceChangeLock.lock(); try { while (balance < amount) sufficientFundsCondition.await();... } finally { balanceChangeLock.unlock(); } }

22. 22 Condition Objects Calling await  Makes current thread wait  Allows another thread to acquire the lock object To unblock, another thread must execute signalAll on the same condition object signalAll unblocks all threads waiting on the condition sufficientFundsCondition.signalAll();

23. 23 Condition Objects signal : randomly picks just one thread waiting on the object and unblocks it signal can be more efficient, but you need to know that every waiting thread can proceed Recommendation: always call signalAll

24. 24 Conclusion Lab 8 Part 3 Assigned – Due by Midnight on the 15th Quiz 6 Now In Lab Afterwards