Suspending a thread is when we temporarily pause a thread, rather than stop and destroy it. This thread can be resumed at a later stage.

When Java was first introduced threads were a part of the language and worked fine. There were some difficulties with multi-Platform versions. With the introduction of Java 2 threads were updated to prevent certain race and lock conditions that occurred. In the Thread class there were suspend() and resume() methods, but these have been deprecated for JDK1.2+ and so should not be used - you will get deprecated warnings from the Java compiler if used, and they will lead to unpredictable threaded code if these warnings are ignored.

Figure 11.3, “A Suspend/Resume Multi-Counter Example” displays a capture of an applet that has suspend/resume functionality on two separate threads. CounterApplet.html show this applet running. Note that the two textfields are controlled by the same buttons, but they are different threads that start at different points 0 and 50 and count at different rates. The first one counts every 100ms, whereas the second counts every 200ms (i.e. at half the speed).

Figure 11.3. A Suspend/Resume Multi-Counter Example

The source code is as below and as in CounterApplet.java.

  1 
  2 
  3   // A Working Counting Applet - by Derek Molloy
  4 
  5   import java.applet.*;
  6   import java.awt.*;
  7   import java.awt.event.*;
  8 
  9   public class CounterApplet extends Applet implements ActionListener
 10   {
 11 	private Button start, stop, toggle;
 12 	private TextField countField1, countField2;
 13 	private Counter theCounter1, theCounter2;
 14 
 15 	public void init() 
 16 	{
 17 	  countField1 = new TextField(10);
 18 	  countField2 = new TextField(10);
 19 	  this.add(countField1);
 20 	  this.add(countField2);
 21 
 22 	  start = new Button("Start");
 23 	  start.addActionListener(this);
 24 	  this.add(start);
 25 
 26 	  stop = new Button("Stop");
 27 	  stop.addActionListener(this);
 28 	  this.add(stop);
 29 
 30 	  toggle = new Button("Toggle");
 31 	  toggle.addActionListener(this);
 32 	  this.add(toggle);
 33 
 34 	  this.theCounter1 = new Counter(countField1, 100, 0);
 35 	  this.theCounter2 = new Counter(countField2, 200, 50);
 36 	}
 37 	
 38 	public void actionPerformed(ActionEvent e) 
 39 	{
 40 	  if (e.getSource().equals(start))
 41 	  {
 42 	    this.theCounter1.start();
 43 	    this.theCounter2.start();
 44 	  }
 45 	  else if (e.getSource().equals(stop))
 46 	  {
 47 	    this.theCounter1.stopCounter();
 48 	    this.theCounter2.stopCounter();
 49 	  }
 50 	  else if (e.getSource().equals(toggle))
 51 	  {
 52 	    this.theCounter1.toggleCounter();
 53 	    this.theCounter2.toggleCounter();
 54 	  }
 55 	}
 56   } 
 57 
 58 
 59 
 60   class Counter extends Thread
 61   {
 62 	private int count, delay;
 63 	private boolean running = true, paused = false;
 64 	private TextField theField;
 65 
 66 	
 67 	public Counter(TextField t, int delay, int startValue)
 68 	{
 69 	  this.theField = t;
 70 	  this.count = startValue;
 71 	  this.delay = delay;
 72 	}
 73 
 74 	public void run() 
 75 	{
 76 	  while (running) 
 77 	  {
 78 	    theField.setText("Count: "+this.count++);
 79 	    try 
 80 	    { 
 81 	      Thread.currentThread().sleep(this.delay); 
 82 
 83 	      synchronized(this) {
 84                     while (this.paused)
 85                         wait();
 86               }
 87 	    } 
 88 	    catch (InterruptedException e)
 89 	    {  
 90 		theField.setText("Interrupted!");
 91 		this.stopCounter();
 92 	    }   
 93 	  }
 94 	}
 95 
 96 	public int getCount() { return count; }	// not used in this example
 97 
 98 	public void stopCounter() { this.running = false; }
 99 
100 	public synchronized void toggleCounter()
101 	{ 
102 	  this.paused = !this.paused; 
103 	  if (!this.paused) notify();
104 	}
105   }
106 
107 

I have changed the code from the section called “A Working Counter” to have two separate classes. I did this to prevent any confusion between the Applet class and the thread itself, and to allow for the creation of two separate thread objects. The Applet class creates three buttons as in Figure 11.3, “A Suspend/Resume Multi-Counter Example” and two TextField objects. So how does this code work?

Task: Modify the applet as shown in Figure 11.3, “A Suspend/Resume Multi-Counter Example” to add the following functionality:

You can see a screen-grab of my solution in Figure 11.4, “My Up/Down Counter Solution” and you can see it running here - UpDownCounterApplet.html. For my example I have set the maximum value of each counter to 200. Note that the slower counter will continue to count until it too reaches 200.

Figure 11.4. My Up/Down Counter Solution

Solution: The solution is here - UpDownCounterApplet.java but please do not look at it until you have had a good attempt yourself.

Java has thread scheduling that monitors all running threads in all programs and decides which thread should be running. There are two main type of thread:

There are two main forms of scheduler: (i) Preemptive that gives a certain time slice to each thread. The scheduler sets up the order that the threads run in. (ii)Non-preemptive that runs a thread until it is complete. Each thread has control of the processor for as long as it requires.

New threads inherit the priority and daemon flag from the thread that created it.

The scheduler decides which thread should be running based on a priority value assigned to the thread. The priority number has a value between 1 and 10 and a thread runs more often if it has a higher priority value. There are three pre-defined priorities:

You can use the setPriority() to set the priority level of a thread, so if you wished to set a Thread object called testThread to be running at the highest priority possible, you could call testThread.setPriority(Thread.MAX_PRIORITY); The method getPriority can be used to return the priority level of a given thread. It returns an int value, as per the list above.

I have written a short example based on the code in the section called “Suspending and Resuming Threads” to show you the effect of priorities on threads. This example sets the first Counter object to have the maximum priority and the second Counter object to have the minimum priority. The first counter starts with a value of 0 and the second counter starts with the higher value of 200. I set the delay between counting to be 1ms, in the hope that my machine will not be able to handle that speed of counting and so will give more priority to the first counter. You can see the results in Figure 11.5, “Priority Counter Example”, where a screen-grab of this example running shows that the first counter has caught up with the second counter after ~65526ms, i.e. just over 1 minute. You can also run it here - PriorityCounterApplet.html.

Figure 11.5. Priority Counter Example

The code for this example is below and in PriorityCounterApplet.java

  1 
  2 
  3   // A Working Counting Scheduled Applet - by Derek Molloy
  4 
  5   import java.applet.*;
  6   import java.awt.*;
  7   import java.awt.event.*;
  8 
  9   public class PriorityCounterApplet extends Applet implements ActionListener
 10   {
 11 	private Button start, stop, toggle;
 12 	private TextField countField1, countField2;
 13 	private Counter theCounter1, theCounter2;
 14 
 15 	public void init() 
 16 	{
 17 	  countField1 = new TextField(10);
 18 	  countField2 = new TextField(10);
 19 	  this.add(countField1);
 20 	  this.add(countField2);
 21 
 22 	  start = new Button("Start");
 23 	  start.addActionListener(this);
 24 	  this.add(start);
 25 
 26 	  stop = new Button("Stop");
 27 	  stop.addActionListener(this);
 28 	  this.add(stop);
 29 
 30 	  toggle = new Button("Toggle");
 31 	  toggle.addActionListener(this);
 32 	  this.add(toggle);
 33 
 34 	  this.theCounter1 = new Counter(countField1, 0);
 35 	  this.theCounter1.setPriority(Thread.MAX_PRIORITY);
 36 	  this.theCounter2 = new Counter(countField2, 200);
 37 	  this.theCounter2.setPriority(Thread.MIN_PRIORITY);
 38 	}
 39 	
 40 	public void actionPerformed(ActionEvent e) 
 41 	{
 42 	  if (e.getSource().equals(start))
 43 	  {
 44 	    this.theCounter1.start();
 45 	    this.theCounter2.start();
 46 	  }
 47 	  else if (e.getSource().equals(stop))
 48 	  {
 49 	    this.theCounter1.stopCounter();
 50 	    this.theCounter2.stopCounter();
 51 	  }
 52 	  else if (e.getSource().equals(toggle))
 53 	  {
 54 	    this.theCounter1.toggleCounter();
 55 	    this.theCounter2.toggleCounter();
 56 	  }
 57 	}
 58   } 
 59 
 60 
 61   class Counter extends Thread
 62   {
 63 	private int count;
 64 	private boolean running = true, paused = false;
 65 	private TextField theField;
 66 
 67 	
 68 	public Counter(TextField t, int startValue)
 69 	{
 70 	  this.theField = t;
 71 	  this.count = startValue;
 72 	}
 73 
 74 	public void run() 
 75 	{
 76 	  while (running) 
 77 	  {
 78 	    theField.setText("Count: "+this.count++);
 79 	    try 
 80 	    { 
 81 	      Thread.currentThread().sleep(1); 
 82 
 83 	      synchronized(this) {
 84                     while (paused)
 85                         wait();
 86               }
 87 	    } 
 88 	    catch (InterruptedException e)
 89 	    {  
 90 		theField.setText("Interrupted!");
 91 		this.stopCounter();
 92 	    }   
 93 	  }
 94 	}
 95 
 96 	public int getCount() { return count; }
 97 
 98 	public void stopCounter() { this.running = false; }
 99 
100 	public synchronized void toggleCounter()
101 	{ 
102 	  this.paused = !this.paused; 
103 	  if (!this.paused) notify();
104 	}
105   }
106 
107 

This applet will run at different speeds on different machines. I did not want to give a delay of 0, i.e. sleep(0) as this would allocate no resources to the system and could lead to unresponsive buttons and a serious CPU load on your PC - Try it if you like!