1. 1 CS2200 Software Development Lecture: Multi-threading II A. O’Riordan, 2009

2. 2 Thread Priorities Java Threads have a priority – can use getPriority() method in Thread class Priority is thread ranking - Some threads can either run for a longer time-slice or run more often (depending on the operating system) Peers (or equals) get the same time/number of runs Priority is set from constants MIN_PRIORITY (currently 1) to MAX_PRIORITY (currently 10) using the setPriority(int) method NORM_PRIORITY is the midrange value (currently 5).

3. 3 Thread Priority Issues Higher priority threads can interrupt (pre-empt) lower priority ones To lower the priority of a thread by 1 t1.setPriority(t1.getPriority() -1); Each new thread has the same priority as that of the thread that created it Low priority threads are in danger of starvation –when one thread cannot access the CPU because one or more other threads are monopolizing it –yield() method relinquishes control which may enable others to be run

4. 4 ThreadGroup Every Java thread is a member of a thread group, by default the same group as that of the thread issuing the constructor for it –Class ThreadGroup (package java.lang) –Add thread to group, grp, using a constructor Thread(grp, new T(), "t1"); Throws SecurityException if the current thread cannot create a thread in the specified thread group Purpose of thread groups is to enforce security, e.g. it is not legal to stop a thread that is not in your group Members of a thread group can invoke operations that affect all members

5. 5 Example Part I public class ThreadGroupTest { public static void main(String[] args){ ThreadGroup grp = new ThreadGroup(“Groupies"); Thread t1 = new Thread(grp, new Task(), "t1"); Thread t2 = new Thread(grp, new Task(), "t2"); t1.start(); t2.start(); System.out.println("ThreadGroup name:” + grp.getName()); System.out.println("There are currently " + grp.activeCount() + " threads running"); System.out.println("The maximum priority of a Thread that can be contained within " + grp.getName() + " is " + grp.getMaxPriority()); }

6. 6 Example Part II class Task implements Runnable{ public void run(){ for (int i = 1; i < 5; i++) { System.out.println("Thread " + Thread.currentThread().getName() + " has a priority of " + Thread.currentThread().getPriority()); }

7. 7 Executors (Java 5) To abstract thread management from the rest of your application, pass the application's tasks to an executor Executors define a high-level API for launching and managing threads. Executor implementations provided by java.util.concurrent provide thread pool management suitable for large-scale applications –ExecutorService interface that supports launching new tasks –If r is a Runnable object, and e is an ExecutorService object you can replace Thread t = new Thread(r); t.start() with e.execute(r) However, the definition of execute is less specific. The first option creates a new thread and launches it immediately. Depending on the implementation, execute may do the same thing, but is more likely to use an existing worker thread to run r, or to place r in a queue to wait for a worker thread to become available

8. 8 Thread Pools A Thread pool consist of worker threads that exists separately from the Runnable they execute A fixed thread pool always has a specified number of threads running; if a thread is somehow terminated while it is still in use, it is automatically replaced with a new thread Tasks are submitted to the pool via an internal queue, which holds extra tasks whenever there are more active tasks than threads Executors method newFixedThreadPool() returns an ExecutorService that creates 2 threads (method newCachedThreadPool returns an ExecutorService that creates threads as they are needed)

9. 9 Executors Example Assuming there’s a class Task that implements Runnable: Task task1 = new Task("task1"); Task task2 = new Task("task2") Task task3 = new Task("task3"); System.out.println("Starting threads"); ExecutorService threadExecutor = Executors.newFixedThreadPool(2); threadExecutor.execute(task1); threadExecutor.execute(task2); threadExecutor.execute(task3); threadExecutor.shutdown(); // shutdown worker threads

10. 10 What’s happing The code in method main executes in the main thread Creates three Task objects (no extra threads are this stage) Create an executor that uses a fixed thread pool by invoking newFixedThreadPool() factory method in Executors (returns a ExecutorService object) execute() creates a new Thread inside the ExecutorService and returns immediately from each invocation ExecutorService method shutdown() will end each Thread in threadExecutor as soon as each finishes executing its Runnable and there are none queuing The program will not terminate until its last thread completes execution

11. 11 Daemon threads A Java program exits when all of its threads have completed but this is not the full story. What about the hidden system threads, such as the garbage collection thread and others created by the JVM? We have no way of stopping these. These system threads are called daemon threads. A Java program actually exits when all its non-daemon threads have completed Programmer can create daemon threads as well (not covered).

12. 12 Process v Thread Process - active program – maintains its own set of resources; Thread – sometimes called lightweight process – uses resources of enclosing process Process can be considered as data (address space, files, etc) plus one or more threads All threads live in the same memory space Threads can easily exchange data among themselves simply by accessing shared variables (static or instance fields), but threads must also ensure that they access shared variables in a controlled manner

13. 13 Technical Issues Deciding what should be a thread – not all objects should have their own threads Liveness – a thread can be starved of CPU cycles or threads can be deadlocked (waiting for each other in order to continue) Synchronization – need exclusion mechanisms to maintain threads in a consistent state Non-determinism – different executions of a program can result in different interleaving Thread construction overhead – performance hit of creating and setting threads running

14. 14 Execution context Execution context managed by JVM Execution context – a way to create/delete execution context, save and maintain state, dispatch to another thread’s execution context Scheduling – determine which thread to switch to and when (e.g. run-until-blocked, round robin time-slicing) Synchronization – coordinate the use of shared resources, e.g. mutexs (mutual exclusions) for shared resources; buffering for producers and consumers Op Sys (e.g. Linux) has it’s own execution context underneath

15. 15 Producer/Consumer: The Box class public class Box { private int total; public Box() { total = 0; } public void put() { int bigger = total + 1; System.out.println("Putting something in" + "; new total is " + bigger); total = bigger; } public void get() { int smaller = total - 1; System.out.println("Taking something out" + "; new total is " + smaller); total = smaller; }

16. 16 Thread accessing another object public class Producer extends Thread { public Box box; public Producer(Box b) { box = b; } public void run() { try { for (int i = 0; i < 50; i++) { box.put(); sleep(100); } catch (InterruptedException e) { } }... And assume a similar thread for consuming the items and a main program starting both Threads…... And assume a similar thread for consuming the items and a main program starting both Threads…

17. 17 Race Condition But the final total is not necessarily 0! –the two threads are sharing resource, and because of thread scheduling, there is no guarantee that the other thread does not jump in and change it in the middle of an update race condition - the threads are racing to complete their tasks and the final result depends on which one wins the race –a thread must "lock" the data or objects it is going to change –if an object is locked, no other object can modify its state –Java allows us to do this by specifying that a method is synchronized –if the thread running it sleeps, the data remains locked –Java handles all the locking and unlocking for us

18. 18 Synchronizing Add keyword synchronized to code: public synchronized void get() {…} public synchronized void put() {…} Aso try to ensure co-ordinated behaviour by only put an item when box is empty and only get an item when there is item in box public synchronized void put(Thread th) { while (total > 0 ) try { th.sleep(10); } catch (InterruptedException ie) { } // rest of code }... doesn't work again! this work!

19. 19 Deadlock the put() method is synchronized so once it starts, the box object is locked, and no other thread can get access so if put() is invoked while total == 1, it locks the object, puts the thread to sleep, wakes up 10 millisecs later, sees that total is 1, goes back to sleep, and repeats for ever We have Deadlock!

20. 20 Avoiding deadlock –instead of putting the thread to sleep, we can tell the method to wait until an appropriate time –each time the consumer or producer changes the total, it should notify all other threads that the value has changed –the threads then reactivate, and check the condition public synchronized void put() { while (total > 0 ) try { wait(); } catch (InterruptedException ie) { } int newTotal = total + 1; notifyAll();... } wait() and notifyAll() are methods of the Object class wait() and notifyAll() are methods of the Object class

21. 21 Resources Java Threads/Concurrency Tutorials –http://java.sun.com/docs/books/tutorial/essential/concurrency/http://java.sun.com/docs/books/tutorial/essential/concurrency/ –http://www.freejavaguide.com/java-threads-tutorial.pdfhttp://www.freejavaguide.com/java-threads-tutorial.pdf –http://java.sun.com/j2se/1.5.0/docs/guide/concurrency/overview.htmlhttp://java.sun.com/j2se/1.5.0/docs/guide/concurrency/overview.html Dedicated Books on Java Concurrency –Java Concurrency in Practice, Brian Goetz et al., Addison-Wesley Professional,, 2006 –Concurrent Programming in Java, Second Edition, Doug Lea, Addison- Wesley, 1999 (Java 2) –Java Threads, Third Edition, Scott Oaks and Henry Wong, O'Reilly, 2004