Module 12: Threads

	  Thread.sleep ((int)UniformRandom.uniform (3,6));
  

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 rules of the dog race as follows:

• When a dog sees that it is more than 20 paces (pixels) ahead of the other dog, it sportingly 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 setPosition (int ID, int newPosition)
      {
      }
  
      // Get the current position of Dog# ID.  
      public synchronized int getPosition (int ID)
      {
      }
  
      // Wait.  
      public synchronized void synchWait ()
      {
      }
  
      // Tell the other dog that it can continue.  
      public synchronized void synchNotify ()
      {
      }
  }
      

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

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

• 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 JFrame {

    // ...   

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


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

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

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

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

        // Create a Thread instance for each dog.  
        Thread dThread1 = new Thread (d1);
        Thread dThread2 = new Thread (d2);

        // Start running the threads.  
        dThread1.start();
        dThread2.start();
    }

}


// A monitor class with synchronized access.  

class DogMonitor {

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

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

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

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

    // A waiting dog needs to call a synchronized  
    // wait method inside the monitor.  
    public synchronized void synchWait ()
    {
        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 synchNotify ()
    {
        // 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, JPanel drawingArea, DogMonitor monitor, int OtherID)
    {
        // ... store parameters ...  
    }

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

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

        // While not complete...  
        while (monitor.getPosition (ID) < finishLine) {
            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.getPosition (OtherID);
            int mine = monitor.getPosition (ID);
            if (mine - other > 20) {
 	        System.out.println ("ID=" + ID + " waiting: mine=" + mine
			    + ", other=" + other);
                monitor.synchWait ();
    	        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.synchNotify();
            }
        } // 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 synchronized method inside the class.
  • Thus, suppose Thread A is currently executing the method setPosition.
    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 synchWait ()
    {
        try {
            // wait() is inherited from Object.  
            wait ();
        }
        catch (InterruptedException e)
        {
            System.out.println (e);
        }
    }
      

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

Exercise 12.9: Try executing the above code. What do you observe?

Deadlock

It is possible for the above code to deadlock.

• Deadlock occurs when two threads wait on each other:

  

• Java does not detect deadlock for you and leaves it to you to worry about.

// A monitor class with synchronized access.  

class DogMonitor {

    int[] position;
    boolean[] isWaiting;  // A waiting dog sets a value here.  
    int numDogs;

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

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

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

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

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

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

class DrawPanel extends JPanel {

    // A simple panel extension that draws a circle of a given size.

}


public class SwingThread extends JFrame {

    DrawPanel drawPanel = new DrawPanel ();


    public SwingThread ()
    {
        this.setSize (600,600);
        
        // Button for Task 1:
        JPanel topPanel = new JPanel ();
        JButton first = new JButton ("Task 1");
        first.addActionListener (
            new ActionListener ()
            {
                public void actionPerformed (ActionEvent a)
                {
                    task1 ();
                }
            }
        );
        topPanel.add (first);

        // Button for Task 2:
        JButton second = new JButton ("Task 2");
        second.addActionListener (
            new ActionListener ()
            {
                public void actionPerformed (ActionEvent a)
                {
                    task2 ();
                }
            }
        );
        topPanel.add (second);

        // ... Quit button etc ...

        this.setVisible (true);
    }
    

    void task1 ()
    {
        // Increase the circle size and re-draw.
        drawPanel.circleSize += 10;
        drawPanel.repaint ();
    }


    void task2 ()
    {
        heavyComputation ();
    }
    

    void heavyComputation ()
    {
        // We'll just fake heavy computation by sleeping.
        try {
            for (int i=1; i<=10; i++) {
                drawPanel.msg = "Task 2: " + i;
                Thread.sleep (1000);
                drawPanel.repaint ();
            }
            drawPanel.msg = "";
            drawPanel.repaint ();
        }
        catch (InterruptedException e){
        }
    }


    public static void main (String[] argv)
    {
        new SwingThread ();
    }

}

  

public class SwingThread2 extends JFrame {

    // ...

    public SwingThread2 ()
    {
        // ...
    }
    

    void task2 ()
    {
        // Make a thread.
        Thread thread = new Thread () {
            public void run () 
            {
                heavyComputation ();
            }
        };
 
        // Fire it off.
        thread.start ();

        // ... Thread ends when heavyComputation() completes execution.
    }
    

    void heavyComputation ()
    {
        // ... 
    }


    // ... 

}