Threading Part 4 CS221 – 4/27/09

The Final Date: 5/7 Time: 6pm Duration: 1hr 50mins Location: EPS 103 Bring: 1 sheet of paper, filled both sides with typed and/or handwritten notes Pick up: In the CS office starting 5/11

Test Review Wednesday: Mindmap exercise Friday: Review anything you need more time on. Answer questions.

Where We Left Off Data integrity options: – Synchronized methods – Synchronized statements using locks – Atomic data access – Immutable objects Order of operations options: – Guarded blocks – Locks

Liveness Problems Can be broken into three categories: – Deadlock – Starvation – Livelock

Deadlock Two or more threads are blocked on each other, waiting forever.

Example

Starvation A thread needs access to a resource but cannot get it for long periods of time Caused by a greedy thread which blocks other threads access to the resource For instance – Imagine a synchronized method that is very slow to return – Thread 1 calls this method often – Thread 2, when calling the method, will often be blocked

Livelock Thread 1 takes action in response to Thread 2 Thread 2 takes action in response to Thread 1 Threads aren’t blocked but they are in an endless loop of responses and won’t do other work.

Livelock Example Alphonse moves to his left to let Gaston pass, while Gaston moves to his right to let Alphonse pass. Seeing that they are still blocking each other, Alphone moves to his right, while Gaston moves to his left. They're still blocking each other, so...

Guarded Blocks In order to coordinate activity between two threads we can use Guarded Blocks Wait() – puts a thread to sleep until it is notified Notify() – wakes up one thread that is waiting on this object NotifyAll() – wakes up all threads waiting on this object

Guarded Blocks Example

Producer-Consumer Example Remember the producer-consumer scenario? Let’s look at a possible implementation – Recall, the previous pseudocode had a thread synchronization problem that could lead to deadlock.

Producer-Consumer Example

Our implementation is inefficient. Why? How do we improve it?

Producer-Consumer Example Things to Notice: – Sleep vs. Wait and Notify – Use of finally – Use of interrupt – What is the impact if we change the buffer size? – What is the impact if we modify the random timeouts?

Lock Objects Recall that every object is associated with an intrinsic lock In order for a thread to get exclusive access to an object, it must: – Acquire the lock before access – Release the lock when it is done

Lock Objects Remember that synchronized methods and statements use locks implicitly: – Thread 1 acquires lock for the Counter object – Thread 1 calls increment method() – Thread 2 tries to acquire the lock – Thread 2 blocks – Thread 1 releases the lock – Thread 2 acquires lock for the Counter object – Thread 2 calls decrement() method

Lock Objects Lock objects give you more sophisticated, explicit access to lock behavior Java.util.concurrent.locks – urrent/locks/package-summary.html urrent/locks/package-summary.html “The framework permits much greater flexibility in the use of locks and conditions, at the expense of more awkward syntax.

Lock Objects Like Intrinsic locks: – Only one thread can hold a lock object at a time – Lock objects support wait() and notify() Lock objects add flexibility: – You can back out of an attempt to acquire a lock Immediately On a timeout On an interrupt – There are a number of lock objects to choose from Read/Write Lock – separate locks for read vs. write access Condition – separate notification mechanisms

Example Alphonse and Gaston are in a loop, continually bowing to each other We want to acquire a lock for each friend before starting a bow Let’s look at how lock objects can help

Example

Things to Notice: – ReentrantLock Object: similar to an intrinsic lock – Use of tryLock() – Use of unlock() – The conditions under which both locks cannot be acquired

Concurrent Collections Java supplies a set of concurrent collections you can use manage sets of data in a multi- threaded program Examples – ArrayBlockingQueue – ConcurrentHashMap – ConcurrentNavigableMap

ArrayBlockingQueue Queue data structure with some added benefits – Blocks when you attempt to add to a full queue – Blocks when you attempt to remove from an empty queue – Wakes up the blocked thread when the queue is ready once more Safe to use with as many threads as you wish

Example Let’s convert producer-consumer to use this datastructure!

ConcurrentHashMap Provides all the functionality of a hash table, plus it is thread-safe. Allows you to add items to the data structure based on a key Supports fast retrieval of the items based on the same key Hashing is much faster than a search, but takes up more space

MultiThreaded Dots Let’s convert our dot moving program to use multiple threads. Steps – Decide what should be in each thread – Move MouseMotionListener to new thread – Move mouse event handlers to the new thread – Start the new thread from MoveComponent constructor

MultiThreaded Dots To be safe: Convert Dots class to use Vector instead of ArrayList – Tip: Vector is thread-safe and ArrayList is not Note: If we’d designed Dots class better we could have replaced ArrayList with Vector without having to modify the calling code. – What would have been a better way to design this class?

Semaphore Semaphore is a generalized version of a mutex. – A mutex is mutually exclusive, only one thread can access at a time. – A semaphore can allow 1..n threads access at a time. – If you reduce semaphore to 1 thread, it is a mutex. oncurrent/Semaphore.html

Thread Priorities You can use thread priority to give some of your threads higher priority than others. Higher priority threads will get more CPU cycles than lower priority threads

Example Create an applet with two counting threads See how the thread priority changes counting speed