More Related Content
Similar to cs4240-multithreading.ppt presentation on multi threading (20)
![[Medicalstudyzone.com] 1. AIIMS NOV EMBER 2015 SOLVED PAPER.pdf](https://cdn.slidesharecdn.com/ss_thumbnails/medicalstudyzone-250904212000-ef4cbf83-thumbnail.jpg?width=560&fit=bounds)
cs4240-multithreading.ppt presentation on multi threading
- 1. Multithreaded Programs in Java
- 2. Tasks and Threads • A task is an abstraction of a series of steps – Might be done in a separate thread – Java libraries use the Runnable interface – work done by method run() • Thread: a Java class for a thread – work done by method run() • How to associate a task with a thread? • How to start a thread?
- 3. Creating a Task and Thread • Warning: old way(s), new ways • First, if you have a thread object, you can call start() on that object – Makes it available to be run – When it’s time to run it, Thread’s run() is called • So, create a thread using “old” (not good) way – Write class that extends Thread, e.g. MyThread – Define your own run() – Create a MyThread object and call start() on it • We won’t do this! Not good design
- 4. Runnables and Thread • Use the “task abstraction” and create a class that implements Runnable interface – Define the run() method to do the work you want • Now, two ways to make your task run in a separate thread – Create a Thread object and pass a Runnable to the constructor – As before, call start() on the Thread object
- 5. Do we need a Thread “manager”? • If your code is responsible for creating a bunch of tasks, linking them with Threads, and starting them all, then you have things to worry about: – What if you start too many threads? Can you manage the number of running threads? – Can you shutdown all the threads? – If one fails, can you restart it?
- 6. Executors • An Executor is an object that manages running tasks – Submit a Runnable to be run with Executor’s execute() method – So, instead of creating a Thread for your Runnable and calling start() on that, do this: • Get an Executor object, say called exec • Create a Runnable, say called myTask • Submit for running: exec.execute(myTask)
- 7. How to Get an Executor • Use static methods in Executors library. • Fixed “thread pool”: at most N threads running at one time Executor exec = Executors.newFixedThreadPool(MAX_THREADS); • Unlimited number of threads Executor exec = Executors.newCachedThreadPool();
- 8. Summary So Far • Create a class that implements a Runnable to be your “worker” • Create Runnable objects • Create an Executor • Submit each Runnable to the Executor which starts it up in a separate thread
- 10. Synchronization • Understand the issue with concurrent access to shared data? – Data could be a counter (int) or a data structure (e.g. a Map or List or Set) • A critical section: a block of code that can only be safely executed by one thread at a time • A lock: an object that is “held” by one thread at a time, then “released”
- 11. Synchronization in Java (1) • Any object can serve as a lock – Separate object: Object myLock = new Object(); – Current instance: the this object • Enclose lines of code in a synchronized block synchronized(myLock) { // code here } • More than one thread could try to execute this code, but one acquires the lock and the others “block” or wait until the first thread releases the lock
- 12. Synchronized Methods • Common situation: all the code in a method is a critical section – I.e. only one thread at a time should execute that method – E.g. a getter or setter or mutator, or something that changes shared state info (e.g. a Map of important data) • Java makes it easy: add synchronized keyword to method signature. E.g. public synchronized void update(…) {
- 13. Summary So Far • Concurrent access to shared data – Can lead to serious, hard-to-find problems – E.g. race conditions • The concept of a lock • Synchronized blocks of code or methods – One thread at a time – While first thread is executing it, others block
- 15. More Advanced Synchronization • A semaphore object – Allows simultaneous access by N threads – If N==1, then this is known as a mutex (mutual exclusion) – Java has a class Semaphore • Java class CountDownLatch – Created with a count (often a number of “worker” threads). Say object is allWorkersDone – Another thread (a “manager”) waits for all the workers to call countDown() on that object – So manager blocks with: allWorkersDone.await()
- 16. Barriers • Java class CyclicBarrier – A rendezvous point or barrier point – Worker threads wait at a spot until all get there – Then all proceed
- 17. Using CountDownLatch • Here are some common scenarios and demo programs for them • You’ll use the last of these for the War card- game program!
- 18. Scenario #1 • A “manager” thread and N “worker” threads • Manager starts workers but then must wait for them to finish before doing follow-up work • Solution: – Manager creates a CountDownLatch with value N – After workers starts, manager calls await() on that – When each worker completes its work, it calls countDown() on the latch – After all N call countDown(), manager is un-blocked and does follow-up work • Example use: parallel divide and conquer like mergesort • Code example: SyncDemo0.java
- 19. Scenario #2 • A “manager” thread and N “worker” threads • Manager starts workers but wants them to “hold” before doing real work until it says “go” • Solution: – Manager creates a CountDownLatch with value 1 – After each workers start, it calls await() on that Latch – At some point, when ready, the manager calls countDown() on that Latch – Now Workers free to continue with their work • Code example: SyncDemo1.java
- 20. Scenario #3 • Work done in “rounds” where: – All workers wait for manager to say “go” – Each worker does its job and then waits for next round – Manager waits for all workers to complete a round, then does some follow-up work – When that’s done, manager starts next round by telling workers “go” • Solution: combine the two previous solutions – First Latch: hold workers until manager is ready – Second Latch: manager waits until workers finish a round – Worker’s run() has loop to repeat – Manager must manage Latches, recreating them at end of round • Example use: a card game or anything that has that kind of structure • Code example: SyncDemo2.java
- 21. Summary of last section • Multiple threads may need to cooperate – Common situation: some workers and a manager – One thread may need to wait for one or more thread to complete – One or more threads may need to wait to be “released” – Or a combination of these situations • Threads all access a CountDownLatch – await() used to wait for enough calls to countDown()
- 22. End • Unused slides follow