Multithreading with GUI

This program uses separate threads to modify the content displayed in a Swing GUI. The nature of multithreaded programming prevents the programmer from knowing exactly when a thread will execute. Swing components are not thread safeif multiple threads manipulate a Swing GUI component, the results may not be correct. All interactions with Swing GUI components should be performed as part of the event-dispatching thread (also known as the event-handling thread). Class SwingUtilities (package javax.swing) provides static method invokeLater to help with this process. Method invokeLater specifies GUI processing statements to execute later as part of the event-dispatching thread. Method invokeLater receives as its argument an object that implements interface Runnable. The method places the Runnable as an event into the event-dispatching thread's queue of events. These events are processed in the order they appear in the queue. Because only one thread handles these events, it can be guaranteed that the GUI will be updated properly.

Our next example (Fig. 23.17) demonstrates this concept. When this program calls invokeLater, the GUI component update will be queued for execution in the event-dispatching thread. The Runnable's run method will then be invoked as part of the event-dispatching thread to perform the output and ensure that the GUI component is updated in a thread-safe manner. This example also demonstrates how to suspend a thread (i.e., temporarily prevent it from executing) and how to resume a suspended thread.

Figure 23.17. RunnableObject outputs a random uppercase letter on a JLabel. Allows user to suspend and resume execution.

(This item is displayed on pages 1088 - 1090 in the print version)

 1 // Fig. 23.17: RunnableObject.java
 2 // Runnable that writes a random character to a JLabel
 3 import java.util.Random;
 4 import java.util.concurrent.locks.Condition;
 5 import java.util.concurrent.locks.Lock;
 6 import javax.swing.JLabel;
 7 import javax.swing.SwingUtilities;
 8 import java.awt.Color;
 9
10 public class RunnableObject implements Runnable
11 {
12 private static Random generator = new Random(); // for random letters
13 private Lock lockObject; // application lock; passed in to constructor
14 private Condition suspend; // used to suspend and resume thread 
15 private boolean suspended = false; // true if thread suspended 
16 private JLabel output; // JLabel for output
17
18 public RunnableObject( Lock theLock, JLabel label )
19 {
20 lockObject = theLock; // store the Lock for the application 
21 suspend = lockObject.newCondition(); // create new Condition
22 output = label; // store JLabel for outputting character
23 } // end RunnableObject constructor
24
25 // place random characters in GUI
26 public void run() 
27 {
28 // get name of executing thread 
29 final String threadName = Thread.currentThread().getName();
30
31 while ( true ) // infinite loop; will be terminated from outside
32 {
33 try
34 {
35 // sleep for up to 1 second
36 Thread.sleep( generator.nextInt( 1000 ) );
37
38 lockObject.lock(); // obtain the lock 
39 try
40 {
41 while ( suspended ) // loop until not suspended
42 {
43 suspend.await(); // suspend thread execution
44 } // end while
45 } // end try
46 finally
47 {
48 lockObject.unlock(); // unlock the lock
49 } // end finally
50 } // end try
51 // if thread interrupted during wait/sleep
52 catch ( InterruptedException exception )
53 {
54 exception.printStackTrace(); // print stack trace
55 } // end catch
56
57 // display character on corresponding JLabel
58 SwingUtilities.invokeLater( 
59 new Runnable() 
60 {
61 // pick random character and display it
62 public void run()
63 {
64 // select random uppercase letter
65 char displayChar =
66 ( char ) ( generator.nextInt( 26 ) + 65 );
67
68 // output character in JLabel
69 output.setText( threadName + ": " + displayChar );
70 } // end method run 
71 } // end inner class 
72 ); // end call to SwingUtilities.invokeLater
73 } // end while
74 } // end method run
75
76 // change the suspended/running state
77 public void toggle()
78 {
79 suspended = !suspended; // toggle boolean controlling state
80
81 // change label color on suspend/resume
82 output.setBackground( suspended ? Color.RED : Color.GREEN );
83
84 lockObject.lock(); // obtain lock
85 try
86 {
87 if ( !suspended ) // if thread resumed
88 {
89 suspend.signal(); // resume thread
90 } // end if
91 } // end try
92 finally
93 {
94 lockObject.unlock(); // release lock
95 } // end finally
96 } // end method toggle
97 } // end class RunnableObject

Class RunnableObject (Fig. 23.17) implements interface Runnable's run method (lines 2674). Line 29 uses static Thread method currentThread to determine the currently executing thread and Thread method getName to return the name of that thread. Every executing thread has a default name that includes the number of the thread (see the output of Fig. 23.18). Lines 3173 are an infinite loop. [Note: In earlier chapters we have said that infinite loops are bad programming because the application will not terminate. In this case, the infinite loop is in a separate thread from the main thread. When the application window is closed in this example, all the threads created by the main thread are closed as well, including threads (such as this one) that are executing infinite loops.] In each iteration of the loop, the thread sleeps for a random interval from 0 to 1 seconds (line 36).

Figure 23.18. RandomCharacters creates a JFrame with three RunnableObjects and three JCheckBoxes to allow the user to suspend and resume threads.

(This item is displayed on pages 1091 - 1093 in the print version)

 1 // Fig. 23.18: RandomCharacters.java
 2 // Class RandomCharacters demonstrates the Runnable interface
 3 import java.awt.Color;
 4 import java.awt.GridLayout;
 5 import java.awt.event.ActionEvent;
 6 import java.awt.event.ActionListener;
 7 import java.util.concurrent.Executors;
 8 import java.util.concurrent.ExecutorService;
 9 import java.util.concurrent.locks.Condition;
10 import java.util.concurrent.locks.Lock;
11 import java.util.concurrent.locks.ReentrantLock;
12 import javax.swing.JCheckBox;
13 import javax.swing.JFrame;
14 import javax.swing.JLabel;
15
16 public class RandomCharacters extends JFrame implements ActionListener
17 {
18 private final static int SIZE = 3; // number of threads
19 private JCheckBox checkboxes[]; // array of JCheckBoxes
20 private Lock lockObject = new ReentrantLock( true ); // single lock
21
22 // array of RunnableObjects to display random characters
23 private RunnableObject[] randomCharacters =
24 new RunnableObject[ SIZE ];
25
26 // set up GUI and arrays
27 public RandomCharacters()
28 {
29 checkboxes = new JCheckBox[ SIZE ]; // allocate space for array
30 setLayout( new GridLayout( SIZE, 2, 5, 5 ) ); // set layout
31
32 // create new thread pool with SIZE threads 
33 ExecutorService runner = Executors.newFixedThreadPool( SIZE );
34
35 // loop SIZE times
36 for ( int count = 0; count < SIZE; count++ )
37 {
38 JLabel outputJLabel = new JLabel(); // create JLabel
39 outputJLabel.setBackground( Color.GREEN ); // set color
40 outputJLabel.setOpaque( true ); // set JLabel to be opaque
41 add( outputJLabel ); // add JLabel to JFrame
42
43 // create JCheckBox to control suspend/resume state
44 checkboxes[ count ] = new JCheckBox( "Suspended" );
45
46 // add listener which executes when JCheckBox is clicked
47 checkboxes[ count ].addActionListener( this );
48 add( checkboxes[ count ] ); // add JCheckBox to JFrame
49
50 // create a new RunnableObject
51 randomCharacters[ count ] =
52 new RunnableObject( lockObject, outputJLabel );
53
54 // execute RunnableObject 
55 runner.execute( randomCharacters[ count ] );
56 } // end for
57
58 setSize( 275, 90 ); // set size of window
59 setVisible( true ); // show window
60
61 runner.shutdown(); // shutdown runner when threads finish
62 } // end RandomCharacters constructor
63
64 // handle JCheckBox events
65 public void actionPerformed( ActionEvent event )
66 {
67 // loop over all JCheckBoxes in array
68 for ( int count = 0; count < checkboxes.length; count++ )
69 {
70 // check if this JCheckBox was source of event
71 if ( event.getSource() == checkboxes[ count ] )
72 randomCharacters[ count ].toggle(); // toggle state
73 } // end for
74 } // end method actionPerformed
75
76 public static void main( String args[] )
77 {
78 // create new RandomCharacters object
79 RandomCharacters application = new RandomCharacters();
80
81 // set application to end when window is closed
82 application.setDefaultCloseOperation( EXIT_ON_CLOSE );
83 } // end main
84 } // end class RandomCharacters

 

When the thread awakens, line 38 acquires the Lock on this application. Lines 4144 loop while the boolean variable suspended is TRue. Line 43 calls method await on Condition suspend to temporarily release the Lock and place this thread into the waiting state. When this thread is signaled, it reacquires the Lock, moves back to the runnable state and releases the Lock (line 48). When suspended is false, the thread should resume execution. If suspended is still true, the loop executes again.

Lines 5872 call SwingUtilities method invokeLater. Lines 5971 declare an anonymous inner class that implements the Runnable interface, and lines 6270 declare method run. The method call to invokeLater places this Runnable object in a queue to be executed by the event-dispatching thread. Lines 6566 create a random uppercase character. Line 69 calls method setText on the JLabel output to display the thread name and the random character on the JLabel in the application window.

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). Suspending and resuming of a thread can be implemented by using thread synchronization and Condition methods await and signal. Lines 7796 declare method toggle, which will change the suspended/resumed state of the current thread. Line 79 reverses the value of boolean variable suspended. Line 82 changes the background color of the JLabel by calling method setBackground. If the thread is suspended, the background color will be Color.RED, whereas if the thread is running, the background color will be Color.GREEN. Method toggle is called from the event handler in Fig. 23.18, so its tasks will be performed in the event-dispatch threadthus, there is no need to use invokeLater for line 82. Line 84 acquires the Lock for this application. Line 87 then tests whether the thread was just resumed. If this is true, line 89 calls method signal on Condition suspend. This method call will alert a thread that was placed in the waiting state by the await method call in line 43. Line 94 releases the Lock on this application inside a finally block.

Note that the if statement in line 87 does not have an associated else. If this condition fails, it means that the thread has just been suspended. When this happens, a thread executing at line 38 will enter the while loop and line 43 will suspend the thread with a call to method await.

Class RandomCharacters (Fig. 23.18) displays three JLabels and three JCheckBoxes. A separate thread of execution is associated with each JLabel and JCheckBox pair. Each thread randomly displays letters from the alphabet in its corresponding JLabel object. Line 33 creates a new ExecutorService with method newFixedThreadPool. Lines 3656 iterate three times. Lines 3841 create and customize the JLabel. Line 44 creates the JCheckBox, and line 47 adds an ActionListener for each JCheckBox (this will be discussed later.) Lines 5152 create a new RunnableObject implements the Runnable interface. Line 55 executes the RunnableObject with one of the threads of execution created in runner in line 33.

If the user clicks the Suspended checkbox next to a particular JLabel, the program invokes method actionPerformed (lines 6574) to determine which checkbox generated the event. Lines 6873 determine which checkbox generated the event. Line 71 checks whether the source of the event is the JCheckBox in the current index. If it is, line 72 calls method toggle (lines 7592 of Fig. 23.17) on that RunnableObject.