Module 12: Threads

The following is one approach to handling waiting and notification:

• Define a new class to act as a monitor.
  
  
• Then, place the data that determines waiting inside the monitor.
  
  
• Allow access to this data only via synchronized methods in the monitor.
  
  
• This way, only one thread will be executing inside the class at a time.
  
  
• Use the wait() and notify() (or notifyAll()) methods of the monitor (inherited from Object) to achieve waiting and notification.

As an example, let us modify the dog race as follows:

• When a dog sees that it is more than 20 paces (pixels) ahead of the other dog, it waits until the other comes within a distance of 20.
• When a dog that is behind comes within 20 of the other dog, it notifies (wakes up) the other dog.

To achieve this objective, we will take the following steps:

• We will create a monitor called DogMonitor:

  
  // A monitor class with synchronized access. 
  
  class DogMonitor {
  
    // Set the new position of Dog# ID. 
    public synchronized void set_position (int ID, int new_position)
    {
    }
  
    // Get the current position of Dog# ID. 
    public synchronized int get_position (int ID)
    {
    }
  
    // Wait. 
    public synchronized void synch_wait ()
    {
    }
  
    // Tell the other dog that it can continue. 
    public synchronized void synch_notify ()
    {
    }
  }
      

• Then, we will modify the main loop of a Dog as follows:

  
      while (monitor.get_position (ID) < finish_line) {
  
        // Sleep. 
        
        // Move. 
        
        // If you need to wait, wait. 
  
        // If the other guy is waiting, notify. 
      } // endwhile 
  
      

• To simplify the code, we will remove the feature of forcing the race to stop when one dog wins.

Here is the code: (source file)

class NewFrame extends Frame {

  // ...  

  public NewFrame ()
  {
    // ... same as before ... 
  }


  void race ()
  {
    Dimension D = c.getSize ();

    // Finish-line is at the right end of the canvas. 
    int finish_line = D.width;

    // Create the dog monitor. 
    DogMonitor monitor = new DogMonitor (2);

    // Create two dog instances with different ID's. 
    Dog d1 = new Dog (1, c, monitor, 2);
    Dog d2 = new Dog (2, c, monitor, 1);

    // Create a Thread instance for each dog. 
    // Note: the class Dog must implement the 
    // Runnable interface. 
    Thread d1_thread = new Thread (d1);
    Thread d2_thread = new Thread (d2);

    // Start running the threads. 
    // ("start" is a method in Thread). 
    d1_thread.start();
    d2_thread.start();
  }


}


// A monitor class with synchronized access. 

class DogMonitor {

  // The position of each dog. 
  int[] position;

  public DogMonitor (int num_dogs)
  {
    position = new int [num_dogs+1];
    for (int i=1; i<=num_dogs; i++)
      position[i] = 20;
  }

  // Set the new position of Dog# ID. 
  public synchronized void set_position (int ID, int new_position)
  {
    position[ID] = new_position;
  }

  // Get the current position of Dog# ID. 
  public synchronized int get_position (int ID)
  {
    return position[ID];
  }

  // A waiting dog needs to call a synchronized 
  // wait method inside the monitor. 
  public synchronized void synch_wait ()
  {
    try {
      // wait() is inherited from Object. 
      wait ();
    }
    catch (InterruptedException e)
    {
      System.out.println (e);
    }
  }

  // Tell the other dog that it can continue. 
  public synchronized void synch_notify ()
  {
    // notify() is inherited from Object. 
    notify ();
  }
}


class Dog implements Runnable {

  // ... 

  DogMonitor monitor;        // Store a reference to the monitor. 
  int OtherID;               // ID of the other dog. 

  public Dog (int ID, Canvas c, DogMonitor monitor, int OtherID)
  {
    // ... store parameters ... 
  }

  public void move ()
  {
    // ... same as before ... 
  }

  public void run ()
  {
    // Compute the finish line distance. 
    int finish_line = c.getSize().width;

    // While not complete... 
    while (monitor.get_position (ID) < finish_line) {
      try {
	Thread.sleep ((int)UniformRandom.uniform (300,600));
      }
      catch (InterruptedException e) {
	System.out.println (e);
      }
      
      move ();
      
      // Check if you need to wait. 
      int other = monitor.get_position (OtherID);
      int mine = monitor.get_position (ID);
      if (mine - other > 20) {
	System.out.println ("ID=" + ID + " waiting: mine=" + mine
			    + ", other=" + other);
	monitor.synch_wait ();
	System.out.println ("ID=" + ID + " continuing");
      }
      
      // See if the other guy is waiting for me. 
      if (other - mine <= 20) {
	System.out.println ("ID=" + ID + " notifying: mine=" + mine
			    + ", other=" + other);
	monitor.synch_notify();
      }
    } // endwhile 

  }

}


public class Race9 {
  // ... 
}
  

Note:

• DogMonitor is a separate class, of which only one instance exists.
  
  
• The accessors and mutators of DogMonitor are all synchronized.
  
  
• The methods wait() and notify() are inherited from Object.
  
  
• The use of these methods works as follows:
  • In Java, each object has an associated monitor (hidden from the programmer).
  • When a number of synchronized methods are defined in a class, only one thread at a time can execute a sychronized method inside the class.
  • Thus, suppose Thread A is currently executing the method set_position.
    Then, no other thread can execute any synchronized method in DogMonitor, even if the method is different.
  • Such a thread blocks (It is made to wait).
  • Thus, the hidden monitor associated with an object has a queue it uses to hold blocked threads.
  • When the currently executing thread completes, a thread is selected from those in the queue to continue execution.
  
  
  
• A thread that executes inside a synchronized method can call the wait() method of the object to deliberately block itself:
  • It then gets placed on the queue of blocked threads.
  
  
  
• A thread can also call the notify() method of the object:
  • This call will result in selecting the highest priority thread from the queue and allowing it to continue execution.
  • As an alternative, a thread can call notifyAll() to wake up all waiting threads.
  • Except for priorities, the programmer has no control over which thread is selected to continue execution.
  
  
  
• Both wait() and notify() (or notifyAll()) must be called from inside synchronized methods, e.g.,

  
    public synchronized void synch_wait ()
    {
      try {
        // wait() is inherited from Object. 
        wait ();
      }
      catch (InterruptedException e)
      {
        System.out.println (e);
      }
    }
      

• The method wait() requires a try-catch block.

Exercise 12.5 (Solution): Try executing the above code. What do you observe?

// A monitor class with synchronized access. 

class DogMonitor {

  int[] position;
  boolean[] is_waiting;  // A waiting dog sets a value here. 
  int num_dogs;

  public DogMonitor (int num_dogs)
  {
    this.num_dogs = num_dogs;
    position = new int [num_dogs+1];
    for (int i=1; i<=num_dogs; i++)
      position[i] = 20;
    is_waiting = new boolean [num_dogs+1];
    for (int i=1; i<=num_dogs; i++)
      is_waiting [i] = false;
  }

  // Set the new position of Dog# ID. 
  public synchronized void set_position (int ID, int new_position)
  {
    position[ID] = new_position;
  }

  // Get the current position of Dog# ID. 
  public synchronized int get_position (int ID)
  {
    return position[ID];
  }

  // Before waiting, make sure no-one else waits. 
  public synchronized void synch_wait (int ID)
  {
    boolean someone_waiting = false;
    for (int i=1; i<=num_dogs; i++)
      if (is_waiting[i]) {
	System.out.println ("synch_wait: i=" + i + " is waiting");
	someone_waiting= true;
      }
    if (someone_waiting) {
      notifyAll();
      for (int i=1; i<=num_dogs; i++)
        is_waiting[i] = false;
    }

    try {
      is_waiting[ID] = true;
      wait ();
    }
    catch (InterruptedException e)
    {
      System.out.println (e);
    }
  }

  public synchronized void synch_notify ()
  {
    notify ();
  }
}
  

class NewFrame extends Frame {

  // ... 

  public NewFrame ()
  {
    // ... 

    // A "pause" button. 
    Button pauseb = new Button ("PAUSE");
    pauseb.addActionListener (
      new ActionListener () {
        public void actionPerformed (ActionEvent a)
        {
	  suspend_race ();
	}
      }
    );
    p.add (pauseb);

    // A "continue" button. 
    Button continueb = new Button ("CONTINUE");
    continueb.addActionListener (
      new ActionListener () {
        public void actionPerformed (ActionEvent a)
        {
	  continue_race ();
	}
      }
    );
    p.add (continueb);

    // ... 
  }

  // ... 

  ThreadGroup DogGroup;

  void race ()
  {
    Dimension D = c.getSize ();

    // Finish-line is at the right end of the canvas. 
    int finish_line = D.width;

    // Create two dog instances with different ID's. 
    Dog d1 = new Dog (1, c);
    Dog d2 = new Dog (2, c);

    // Create a ThreadGroup instance. 
    // Note: a String must be passed as an ID. 
    DogGroup = new ThreadGroup ("All dogs");

    // Create a Thread instance for each dog. 
    Thread d1_thread = new Thread (DogGroup, d1);
    Thread d2_thread = new Thread (DogGroup, d2);

    Dog.start_race();

    // Start running the threads. 
    d1_thread.start();
    d2_thread.start();
  }

  public void suspend_race ()
  {
    DogGroup.suspend ();
  }

  public void continue_race ()
  {
    DogGroup.resume ();
  }

}