The aims of this exercise are:

• to become familiar with the programming tools that you will use during exercises and projects
• to learn how to use threads in Java

Key Cards

Course Home Page

Java Documentation

1. Open a Netscape Navigator window that shows the Java 2 Platform, API Specification. Use the local mirror accessible via the course home page rather than Sun's original (Local mirror: http://www.control.lth.se/intern/dator/java/jdk1.5.0/docs/api/index.html)
2. Look up the Thread class and check which methods that are available

3. Open a new Navigator window that shows the API for se.lth.control.* available at http://www.control.lth.se/~kurstr/InternDator/java/regler/index.html
4. Study the documentation of the classes AnalogIn and AnalogOut.

5. Go to Sun's tutorial. Those of you without any experience of Java are recommended to go through the following in the trail Learning the Java Language :
• Object-oriented programming concepts
• Language basics
• Classes and Objects
• Interfaces and Inheritance

Xemacs

6. Save the file  HelloWorldApp.java (if you do the exercise from a computer outside the LTH domain please instead use  HelloWorldApp.java )in your directory. Open xemacs on this file. All Java source files must have the extension .java. Normally, each file contains only one class, which must be declared public. The name of the source file should be the "name-of-the-public-class".java
7. Explore the different JDE menu choices. The following menu choices are specially useful:
• Java -- Comment out region / Uncomment region
• Java -- Indent line or region (in the case the automatic indentation has been mingled)
• Classes -- class "class-name" (shortcuts to declarations)

Threads

Specification

>java Periodic 500 2000
500, 2000, 500, 500, 500, 500, 2000, 500, 500, 500, 500, 2000, ...

8. Create a new file Periodic.java. This is the file for your program source code. Declare the class Periodic as

public class Periodic extends Thread {

}

    int period;

9. Compile the class from the X-terminal issuing the command

>javac Periodic.java

Declaring a Java program

  public static void main(String[] argv) {

  }

10. Compile the class again, and then run it as a program with the command

>java Periodic

Of course not much happens yet. Actually no thread was created when we ran the program, because no instance of the class was created.

Creating a class instance

public Periodic(int p) {
  period = p;
}

  Periodic m = new Periodic(1000);

11. Compile and run the program.

Running threads

  public void run() {
    System.out.print(period);
    System.out.println(", ");
  }

    m.start();

12. Compile and run the program.

        while (true) {
        }

To make the thread wait for a certain time we call the sleep()method of the Thread class.

  try {
    sleep(period);
  }  catch (Exception e) {}

13. Compile and run the program.

14. Compile and run.

Reading program arguments

15. Use the expression  Integer.parseInt(argv[i]) to convert the i'th input argument string argv[i]to an int. Use a for construction to loop through the program input arguments and construct the corresponding Periodic threads. Try to run the program with some different input arguments, e.g.,

See if you can find situations when the output on the screen is corrupted. The screen is a shared resource. In Exercise 2 you will learn how to ensure that shared resoures are accessed under mutual exclusion.
 
16. How many threads are involved in the execution of the above command? You may use the method Thread.activeCount() if you are not sure about the correct answer.

Creating threads by implementing runnable

     public interface Runnable {
    public void run();
  }
 

17. Define a new class Base in a new file.The class may be empty.
18. Create a new class PeriodicRunnable in a new file. It should extend Base and implement Runnable. The class should have the same functionality as Periodic.

• Since the instances of PeriodicRunnable are no longer instances of Thread, the starting of the thread is now done as

• Another difference is that the static method sleep() belonging to class Thread no longer may be called directly. Instead it must be called through the class name, i.e., as

Internal threads

19. Create a new class PeriodicWithInnerThread that extends Base. Inside the class definition you should define the inner class PeriodicThread by extending Thread. Use a thread reference in PeriodicWithInnerThread to reference an instance of the inner PeriodicThread class. The functionality should be the same as before.

It is also possible to let the inner class be an anonymous class. Using this approach the class  PeriodicWithInnerThread
would contain the following code:

    public class PeriodicWithInnerClass extends Base {

      Thread t = new Thread() {
                               public void run() {
                               // Code to be executed
                               }
                              };

20. Study the class PeriodicWithAnonymousThread. Make sure that you understand it.

A drawback with anonymous classes is that the code often becomes less readable. However, anonymous classes are often used to implement event listeners in Swing.

Thread Priorities

21. Modify the code of Periodic so that it prints out its priority before entering the while loop.
22. Do the same thing for PeriodicRunnable. This must be done in a slightly different way. (Hint: Use the static Thread method currentThread)

23. Modify Periodic so that it executes at a priority that is one above the base priority.
24. Do the same thing for PeriodicRunnable.

Thread Models

The green-thread model is the standard model for reference implementations of Java. Since it does not require any thread support in the operating system, it is very portable. However, for efficiency reasons modern VMs such as the Linux HotSpot VM used in the course use the native-thread model as default.

In the course we use standard Java and pretend that it is a real-time language, although in reality it is not. However, we want our programs to behave in a way that functionally is the same as if the programs would have been written in some real-time language executing on some real-time operating system. For example, we do not want a low priority thread to preempt a high priority thread.

Consider the following example:
 

public class StarvationTest {

  private HighPriorityThread tHigh;
  private LowPriorityThread tLow;
  double sum = 0.0;

  public StarvationTest() {
    tHigh = new HighPriorityThread();
    tLow = new LowPriorityThread();
    tHigh.start();
    tLow.start();
  }

  class HighPriorityThread extends Thread {

    public void run() {
      setPriority(8);
      System.out.println("High priority thread started.");
      while (true) {
        sum = sum + Math.random();
      }
    }
  }

  class LowPriorityThread extends Thread {

    public void run() {
      setPriority(7);
      while(true) {
        System.out.println("Hello");
        try {
          sleep(5000);
        } catch (Exception x) {
        }
      }
    }
  }

  public static void main(String[] argv) {
    StarvationTest s = new StarvationTest();
  }

}

25. Compile and execute the above example. What is the result?

This behaviour is NOT the behaviour that we want on a uni-processor machine. It makes it difficult to detect errors caused by poorly written code. The user believes that everything is correct, even when this is not the case.