University of Sunderland Java Threading, Mutex and Synchronisation Lecture 02 COMM86 Concurrent and Distributed Software Systems

University of Sunderland Program Threads A purely sequential (ie. non-concurrent) program contains a single control path that it follows for any given state of its data This path is referred to as a thread Begin End Instruction 1 Instruction 2 Instruction 3 Instruction 5 Instruction 4 Instruction 0

University of Sunderland Program Threads A concurrent program will consists of any number of concurrently operating threads Begin End Instruction 1 Instruction 2 Instruction 3 Instruction 5 Instruction 4 Instruction 0 Thread 1 Thread 2

University of Sunderland Fork and Join When a single thread becomes a number of additional concurrent threads it is referred to as a fork Begin Instruction 1 Instruction 0 Thread 1 Thread 2 Fork

University of Sunderland Fork and Join When any number of concurrently running threads form a single thread it is referred to as a Join End Instruction 5 Instruction 4 Thread 1 Thread 2 Join

University of Sunderland Synchronisation At some stage it is possible that a number of concurrently running threads may need to temporarily connect with each other (for example to exchange data) This requires that the threads synchronise with each other using some mechanism

University of Sunderland Java Thread Class Java provides a class that allows multi-threaded operation of Java programs This class is called Thread and is part of the java.lang package (so you do not need to import it) To support this, Java also includes the keyword synchronized to effect mutual exclusion between running threads

University of Sunderland Java Thread Mechanism To enable a Java class to operate as a thread do the following: –Write a class that extends the Thread class –Provide a run( ) method in this class that will form the concurrent operations of the class –Call the start( ) method of the class once it has been instantiated –The thread will terminate when the run( ) operation is completed

University of Sunderland An Example A program to create three independently running threads that each output a set of numbers to the console

University of Sunderland Example - Main Program Class public class ThreadExample { public static void main(String argv[]) { ThreadExample theThreadExample = new ThreadExample( ); NumDisplayer[] theNumDisplayers = new NumDisplayer[3]; for(int i = 0; i < 3; i++) { theNumDisplayers[i] = new NumDisplayer(i); // Construct each NumDisplayer theNumDisplayers[i].start( ); // Start each NumDisplayer thread (ie fork) }

University of Sunderland Example - NumDisplayer Class public class NumDisplayer extends Thread { //Extends the java.lang.Thread class int id; public NumDisplayer(int anId) { id = anId; } public void run( ) { //Method that runs when start( ) method of the this class is called for(int i = 0; i < 4; i++) System.out.println("NumDisplayer [" + id + "] displays " + i); }

University of Sunderland Example - Typical Output in MSDOS c:> java ThreadExample NumDisplayer [0] displays 0 NumDisplayer [0] displays 1 NumDisplayer [1] displays 0 NumDisplayer [2] displays 0 NumDisplayer [0] displays 2 NumDisplayer [1] displays 1 NumDisplayer [2] displays 1 NumDisplayer [0] displays 3 NumDisplayer [1] displays 2 NumDisplayer [2] displays 2 NumDisplayer [1] displays 3 NumDisplayer [2] displays 3 c:> Note how the order in which each thread displays to the console is interleaved

University of Sunderland Synchronized Keyword Any Java class method can be declared as synchronized. Once synchronized, only one thread may enter that method at anytime. Other threads wishing to do so block until the orignal thread has completed running the synchronized method. Hence you can use a synchronized method to ensure mutual exclusive access to a class’s data

University of Sunderland Use of Synchronized To make a method synchronized, use the synchronized keyword as a modifier for the method, eg. public synchronized void setData(int newData) { data = newData; } This would allow a single thread to update the data attribute of the class containing the setData() method at any given moment

University of Sunderland Example 2 using synchronized Let us adapt the previous example so the NumDisplayer objects take their value to display from another thread based upon a class called NumCounter

University of Sunderland Example 2 - Main Program Class public class ThreadExample2 { public static void main(String argv[]) { ThreadExample2 theThreadExample = new ThreadExample2( ); NumCounter theNumCounter = new NumCounter( ); // Construct the NumCounter theNumCounter.start( ); // Start the NumCounter NumDisplayer2[] theNumDisplayers = new NumDisplayer2[3]; for(int i = 0; i < 3; i++) { theNumDisplayers[i] = new NumDisplayer2(i, theNumCounter); // Construct each NumDisplayer theNumDisplayers[i].start( ); // Start each NumDisplayer }

University of Sunderland Example 2 - NumCounter Class public class NumCounter extends Thread { int counter; public NumCounter( ) { counter = 0; } public synchronized int getNextNum( ) { int currentNum = counter; updateCounter( ); return currentNum; } public synchronized void updateCounter( ) { counter++; } public void run( ) { while(true) { //Go on and on... try { Thread.sleep(100); // Let other threads operate, see later } catch(InterruptedException ie) { // Required because this exception is thrown by Thread.sleep( ) }

University of Sunderland Example – NumDisplayer2 Class public class NumDisplayer2 extends Thread { int id; NumCounter theNumCounter; // Reference to the NumCounter public NumDisplayer2(int anId, NumCounter aNumCounter) { id = anId; theNumCounter = aNumCounter; } public void run( ) { for(int i = 0; i < 4; i++) System.out.println("NumDisplayer [" + id + "] displays " + theNumCounter.getNextNum( )); }

University of Sunderland Example - Typical Output in MSDOS c:> java ThreadExample2 NumDisplayer [0] displays 0 NumDisplayer [2] displays 1 NumDisplayer [1] displays 2 NumDisplayer [0] displays 3 NumDisplayer [1] displays 4 NumDisplayer [2] displays 5 NumDisplayer [0] displays 6 NumDisplayer [0] displays 7 NumDisplayer [2] displays 8 NumDisplayer [1] displays 9 NumDisplayer [1] displays 10 NumDisplayer [2] displays 11 c:> Note how the order in which each thread displays to the console is still interleaved and that any thread can output any of the possible numbers. This is because we have no control over the sequence that the threads operate in.

University of Sunderland Thread Scheduling Notice that the previous example ensures mutual exclusion, but what about scheduling? Java has a pre-emptive, priority-based thread scheduler This means that if a higher priority thread needs the CPU, a currently running lower priority thread will be interrupted

University of Sunderland Fairness If all threads are of equal priority, then the currently running thread will not be interrupted and get exclusive use of the CPU. Thus we get an unfair scheduling of equal (or lesser) priority threads Because of this, a thread must periodically relinquish its use of the CPU in consideration of other threads

University of Sunderland Thread.sleep( ) To achieve this fairness in your Java programs, use the static method Thread.sleep( ) to temporarily halt any long running thread. This allows other threads access to the CPU. The method takes an integer value parameter that represents the time (in milliseconds) the thread will halt. 100 is a good value for this. Note: the Thread.sleep( ) method throws an InterruptedException exception, so this must be caught

University of Sunderland Thread.sleep( ) Example The NumCounter class used previously introduced a Thread.sleep( ) method call within its run( ) method. (See the previous ThreadExample2 slides)

University of Sunderland Runnable Interface The previous examples have used the idea of extension to enable a class to run as a thread. This is problematic if the class must also extend another class (such as JFrame) To overcome this, you can make the class implement the Runnable interface, which allows the class to be considered a thread

University of Sunderland Runnable Interface The Runnable Interface contains a single run( ) method that needs to be implemented (as per any thread) Once a class implements the Runnable interface, you can construct a thread for this class by passing its class reference to the Thread class constructor Once the thread is started, the run( ) method of the class will be called

University of Sunderland Runnable Interface Example For example public class ThreadExample3 implements Runnable { Thread myThread; // Reference to the thread this object will run upon public ThreadExample3( ) { myThread = new Thread(this); // Construct the thread myThread.start( ); // Start the thread, ie call the run( ) method of the ThreadExample3 class } public static void main(String argv[]) { ThreadExample3 theThreadExample = new ThreadExample3; } public void run( ) { while(true) { // do something, and use Thread.sleep( ) to show consideration to other threads }

University of Sunderland Thread Death Threads stop running under three circumstances: 1. The run( ) method completes 2. You call the stop( ) method of the thread (note this is now a deprecated method so don’t use it!) 3. The whole process within which the thread is running is terminated (i.e. when the Java VM completes) Since we have to control the lifespan of a thread through the run( ) method, it is prudent to make this method come under direct control also by using a completion flag

University of Sunderland Completion Flag Use a boolean variable to indicate whether the thread has completed or not. Use this as the condition for the while statement in the run( ) method, eg. boolean completed = false; public void run( ) { while(!completed) { …. } }

University of Sunderland Is This All? No. The subject of Java threads is large and impossible to do it justice in a single session. There will be more. You can find out more in the Java Tutorial and in most of the Java texts For a near complete treatment of the subject, consult “Java Threads”, Scott Oaks & Henry Wong, O’Reilly, 1997 “Concurrent Programming in Java”, Doug Lea, Addison Wesley, 2000