THE UNIVERSITY OF WESTERN AUSTRALIA
School of Computer Science & Software Engineering

CITS3211 CONCURRENT SYSTEMS: Part II

Laboratory Exercise 1 (not assessed)

The purpose of this laboratory is to:

• Introduce you to the multithreading features of Java.
• Study and run a simple program with two threads.
• Modify the given program for doing more sophisticated tasks and learn other features of multithreading.

Multithreading in Java

You have already briefly seen in the lectures what is meant by multithreading. We will concentrate mainly on the multithreading and synchronization features of Java in these laboratories. To remind you again the essential features of multithreading:

• multithreading is the simultaneous execution of multiple threads of control within the same program or process. By simultaneous we mean that if there is a single CPU, it switches back and forth between the threads.
• All the threads within the same process share a common address space.

Java provides two approaches for creating and managing multiple threads. In this lab, we will see the first approach and study it carefully. Then, we will see the limitations of this approach and study a slightly more general and powerful approach.

Creating Threads

In the first approach, you can create multiple threads using the java.lang.Thread class. The following steps are necessary to do this. I am assuming that you understand how inheritance works in Java. We will see examples of these steps in the code which I will supply later.

• First create a subclass of class Thread through inheritance.
• Override the run() method of the class Thread by your own run() method. Your run() method will be an entry point into the thread's execution.
• Create an instance of the subclass (which you inherited from Thread).
• Since your subclass inherits all methods of the Thread class, it inherits a method called start() from the Thread class. Execute this start() method of your subclass. It initializes the Thread object using the multithreading capabilities of the underlying operating system and invokes the run() method.

An Example

Here is an example program illustrating the above concepts. However, we will modify this example program as we progress through this lab. I will explain this program in detail, but only the new features in future programs will be explained in detail. You should save this program in a file called Example1.java.

The output of the program

Before we go into the details of this program, let us execute it. If you execute this program, you will get different output in different executions! We should expect this since there are multiple (two in fact) threads in the program and we do not have any control over the order in which these threads gets scheduled and rescheduled in the machine. This is a sample output :

thread1: Java
thread1: is
thread2: Java
thread1: an
thread2: is
thread1: exciting
thread2: an
thread1: new
thread2: exciting
thread1: language
thread1: for
thread1: concurrent
thread2: new
thread1: programming.
thread2: language
thread2: for
thread2: concurrent
thread2: programming.

The purpose of this program is to print the following message on the console : Java is an exciting new language for concurrent programming. Two threads are created in the program and each thread prints this message word by word. Whenever a thread prints a word, it prints its identity and a ':' just before the word. In our sample output, you can see how the control switches back and forth between the two threads. If you execute the program many times, you will see all sorts of interleaving of the words.

Explanation

Let us now go through this program and try to understand the details.

• We start our code by importing certain classes from the Java library.
  java.lang.Thread : This class is needed for creating our threads.
  java.lang.System : This is needed for certain system functions like printing.
  java.lang.math : We use some math functions for creating random delays in our program
  java.lang.InterruptedException: For throwing and catching exceptions. You may not bother about the details now.
• class Example1: This is the first of the two classes in our program. It has a simple main(..) method. The first two statements are used to create two threads which are instances of the MyThread class. We also supply the names of the two threads as arguments to the constructor. After that, we simply start the two threads.
• class MyThread: This is the class we create by extending the Thread class (through inheritance). There is only a single data structure in this class. This is a static String which holds the message Java is an exciting new language for concurrent programming word by word. Since there are several methods in this class, we will explain them one by one.
• MyThread(String id): This is the constructor of this class. It takes the name of the thread (e.g., thread1 or thread2) as argument and calls the constructor of the class above it through the super(id) call. Remember that the class above MyThread is the Thread class. So, essentially, this constructor calls the constructor of the Thread class. Whenever a new thread is created, it gets the name supplied through the argument id.
• run(): This is the method we have written to override the run() method of th Thread class. The Thread class has its own run() method, but as soon as you define your own run() method, this will be executed whenever a thread is started.
  The first statement of the run() method uses the getName() method of class Thread to get the name of the thread and stores it in the string name. Then it executes a for loop. The for loop iterates the number of times equal to the number of items in the message array. In each iteration, the thread waits randomly for some time (and may lose the control during this period) and prints a message on the console. The message is nothing but a concatenation of the name of the thread and the current word of the message. Obviously, once all the words are printed, the thread dies.
• randomWait(): This function simply invokes the sleep function to put the thread to sleep. The sleep function needs an argument (the duration of the sleep) and this is supplied by generating a random number through the Math.random() call and multiplying this random number by 1000. Whenever you call the sleep function, you have to throw and catch possible exceptions and hence the call to sleep is within a try{..} block and we print a message if an interrupt is caught.

How does it work?

The program starts as a single thread of execution when the execution of the main(..) method starts. However, two new threads are created immediately after that. So, there are now three threads of control within the program and they all execute independently and simultaneously. You should be able to understand the meaning of the word simultaneously.

Once the two new threads are created, they have all the methods in the class MyThread since they are instances of this class. In addition to that, they inherit all the methods of the Thread class. Also, they share the same address space and hence the array message[]. Now they go on printing the message word by word (and wait in between words) until the array message is completely printed. Also, the control switches back and forth between the two threads (the CPU is scheduled and rescheduled) and we see the different interleaving of the words.

Tasks

• Execute the program as many times as you like.

  See the different interleavings of the words from the two threads. Experiment with the multiplication factor 1000 in method randomWait(). You may increase it, decrease it or omit it. Note that, as you decrease this factor, your threads will sleep less and there is a chance that a thread will not sleep at all, and hence print many words of the message in one shot (in one turn of the CPU). In the extreme case, the words from one thread will be printed first, followed by the words of the other thread. Move on to the next task when you have amused yourself thoroughly.

• Write obituaries for the threads.
  

  In this task, we want to print a message on the console whenever a thread dies. Remember that there are three threads in our program, the thread for the main(..) method in class Example1 and the two threads created in the main().
  There are several different ways of doing this. But there is a restriction. The obituary for a particular thread should be printed only once.
  There is a method in class Thread called isAlive() which can be used for checking whether a thread is alive or not. For example, if you have a line in your program :
  

  thread1.isAlive()

  this call will return a boolean value true as long as thread1 is alive and will return false if thread1 is dead.
  One approach for printing the obituaries for the two threads we have created is to use this isAlive() function. (I should admit that this may not be the best approach). Now of course, a thread itself cannot check whether it is dead, because if it could it won't be dead in the first place. So, we have to place this check somewhere else. A good place is the main(..) method.
  

  Here is one attempt to write obituaries using this idea. Unfortunately, this solution may print an obituary more than once. Save this in a file called Example2.java, execute and see what it does. Correct this solution so that an obituary is printed only once.

  In addition to this, try to write a different program for printing obituaries (by modifying Example1.java).

• Can you explain this?
  

  Here is another version of Example1.java with a little modification. Save this in a file Example3.java and try to find out the difference. Execute it and see the output. Can you explain the output now?

The Second Approach for Multithreading

Creating Threads

In this approach, your class will implement the java.lang.Runnable interface. The Runnable interface consists of a single method, run(): your class must provide an implementation of it. This new run() method provides an entry point into your thread's execution. Your class is not a specialisation of the Thread, but you can obtain a reference to the thread by passing your Runnable object to a constructor of class Thread.

Here is an example program which creates two threads using the above ideas. This program performs the same tasks as the above. You should be able to understand the details by yourself. However, here are some points to note :

• Since MyThread is no longer a subclass of Thread, we cannot use the constructor of the Thread class.
• We pass the newly created objects of the class MyThread to the constructor of the Thread class.
• When we start our threads, the run() method of our class MyThread is executed.

Synchronization

Fix the program by appropriately making methods synchronized, and using wait and notifyAll.

April, 2008.