15.9 Daemon Threads

870 Multithreading Chapter 15

Software Engineering Observation 15.3

The event-dispatch thread is an infinite loop and is not a daemon thread. As such, the event-

dispatch thread will not terminate in a windowed application until the application calls

System method exit.

Good Programming Practice 15.1

Do not assign critical tasks to a daemon thread. They are terminated without warning, which may prevent those tasks from completing properly.

15.10 Runnable Interface

Until now, we extended class Thread to create new classes that support multithreading. We overrode the run method to specify the tasks to be performed concurrently. However, if we want multithreading support in a class that already extends a class other than Thread, we must implement the Runnable interface in that class, because Java does not allow a class to extend more than one class at a time. Class Thread itself implements the Runnable interface (package java.lang) as expressed in the class header

public class Thread extends Object implements Runnable

Implementing the Runnable interface in a class enables a program to manipulate objects of that class as Runnable objects. As with deriving from the Thread class, the code that controls the thread is placed in method run.

A program that uses a Runnable object creates a Thread object and associates the Runnable object with that Thread. Class Thread provides four constructors that can receive references to Runnable objects as arguments. For example, the constructor

public Thread( Runnable runnableObject )

registers method run of runnableObject as the method to be invoked when the thread begins execution. The constructor

public Thread( Runnable runnableObject, String threadName )

constructs a Thread with the name threadName and registers method run of its runnableObject argument as the method to be invoked when the thread begins execution. As always, the thread object’s start method must be called to begin the thread’s execution.

Figure 15.17 demonstrates an applet with a private inner class and an anonymous inner class that each implement interface Runnable. The example also demonstrates how to suspend a thread (i.e., temporarily prevent it from executing), how to resume a suspended thread and how to terminate a thread that executes until a condition becomes false. Each of these techniques is important because Thread methods suspend, resume and stop were deprecated (i.e., they should no longer be used in Java programs) with the introduction of the Java 2 Platform. Because these methods are deprecated, we must code our own mechanisms for suspending, resuming and stopping threads. As we will demonstrate, these mechanisms rely on synchronized blocks of code, loops and boolean flag variables.

35

36// create GUI components, register listeners and attach

37// components to content pane

38for ( int count = 0; count < SIZE; count++ ) {

46container.add( checkboxes[ count ] );

47}

48}

49

50// Create and start threads. This method called after init

51// and when user revists Web page containing this applet

52public void start()

53{

54// create threads and start every time start is called

55for ( int count = 0; count < threads.length; count++ ) {

63threads[ count ].start();

64}

65}

66

67// determine thread location in threads array

68private int getIndex( Thread current )

69{

70for ( int count = 0; count < threads.length; count++ )

75return -1;

76}

77

78// called when user switches Web pages; stops all threads

79public synchronized void stop()

80{

81// Indicate that each thread should terminate. Setting

82// these references to null causes each thread's run

83// method to complete execution.

84for ( int count = 0; count < threads.length; count++ )

Fig. 15.17 Demonstrating the Runnable interface, suspending threads and resuming threads (part 2 of 5).

87// make all waiting threads ready to execute, so they

88// can terminate themselves

89notifyAll();

90}

91

92// handle button events

93public synchronized void actionPerformed( ActionEvent event )

94{

95for ( int count = 0; count < checkboxes.length; count++ ) {

109}

110}

111}

112

113// private inner class that implements Runnable so objects

114// of this class can control threads

115private class RunnableObject implements Runnable {

116

117// Place random characters in GUI. Local variables

118// currentThread and index are declared final so

119// they can be used in an anonymous inner class.

120public void run()

121{

Fig. 15.17 Demonstrating the Runnable interface, suspending threads and resuming threads (part 3 of 5).

182currentThread.getName() + " terminating" );

183}

184

185 } // end private inner class RunnableObject

186

187 } // end class RandomCharacters

Fig. 15.17 Demonstrating the Runnable interface, suspending threads and resuming threads (part 4 of 5).

Fig. 15.17 Demonstrating the Runnable interface, suspending threads and resuming threads (part 5 of 5).

The while loop at lines 129–179 continues to execute as long as the specified Thread reference is equal to the reference to the currently executing thread (currentThread). In each iteration of the loop, the thread sleeps for a random interval from 0 to 1 second.

When the user clicks the JCheckBox to the right of a particular JLabel, the corresponding Thread should be suspended (temporarily prevented from executing) or resumed (allowed to continue executing). In previous versions of Java, methods suspend and resume of class Thread were provided to suspend and resume a thread’s execution. These methods are now deprecated (i.e., they should no longer be used) because they introduce the possibility of deadlock in a program if they are not used correctly. Suspending and resuming of a thread can be implemented using thread synchronization and methods wait and notify of class Object. Lines 137–147 define a synchronized block of code (also called a synchronized statement) that helps suspend the currently executing Thread. When the Thread reaches the synchronized block, the applet object (referenced with RandomCharacters.this) is locked and the while structure tests suspended[ index ] to determine if the Thread should be suspended (i.e., true). If so, line 144 invokes method wait on the applet object to place the Thread in the waiting state. [Note the use of RandomCharacters.this to access the applet class’s this reference from the private inner class RunnableObject.] When the Thread should resume, the program tells all waiting threads to become ready to execute (we will discuss this shortly). However, only the resumed thread will get a chance to execute. The other suspended thread(s) will reenter the waiting state. Lines 156–177 use SwingUtilities method invokeLater to update the JLabel for the appropriate thread. This example uses an anonymous inner class to implement the Runnable interface (lines 161–175) and passes the anonymous inner class object to invokeLater. Lines 167–168 choose a random character from the alphabet string. Lines 170–172 display the character on the appropriate JLabel object.

Software Engineering Observation 15.4

An inner class can reference its outer class’s this reference by preceding the this refer- ence with the outer class name and a dot operator.

If the user clicks the Suspended check box next to a particular JLabel, the program invokes method actionPerformed (lines 93–111). The method determines which checkbox received the event. Using the index of that checkbox in array outputs, line 98 toggles the corresponding boolean in array suspended. Lines 101–102 set the background color of the JLabel to red if the thread is being suspended and green if the thread