Multithreading with GUIs

The nature of multithreaded programming prevents you from knowing exactly when a thread will execute. Windows form components are not thread safeif multiple threads manipulate a Windows GUI component, the results may not be correct. To ensure that threads manipulate GUI components in a thread-safe manner, all interactions with GUI components should be performed by the User Interface thread (also known as the UI thread)the thread that creates and maintains the GUI. Class Control provides method Invoke to help with this process. Method Invoke specifies GUI processing statements that the UI thread should execute. The method receives as its arguments a delegate representing a method that will modify the GUI and an optional array of objects representing the parameters to the method. At some point after Invoke is called, the UI thread will execute the method represented by the delegate, passing the contents of the object array as the method's arguments.

Our next example (Figs. 15.13 and 15.14) uses separate threads to modify the content displayed in a Windows GUI. This example also demonstrates how to use thread synchronization to suspend a thread (i.e., temporarily prevent it from executing) and to resume a suspended thread. The GUI for the application contains three Labels and three CheckBoxes. Each thread in the program displays random characters in a particular Label. The user can temporarily suspend a thread by clicking the appropriate CheckBox and can resume the thread's execution by clicking the same CheckBox again.

Class RandomLetters (Fig. 15.13) contains method GenerateRandomCharacters (lines 3358), which takes no arguments and returns void. Line 36 uses static Thread property currentThread to determine the currently executing thread, then uses the thread's Name property to get the thread's name. Each executing thread is assigned a name that includes the number of the thread in the Main method (see the output of Fig. 15.14). Lines 3857 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 second (line 41).

Figure 15.13. Class RandomLetters outputs random letters and can be suspended.

 1 // Fig. 15.13: RandomLetters.cs
 2 // Writes a random letter to a label
 3 using System;
 4 using System.Windows.Forms;
 5 using System.Drawing;
 6 using System.Threading;
 8 public class RandomLetters
 9 {
10 private static Random generator = new Random(); // for random letters
11 private bool suspended = false; // true if thread is suspended 
12 private Label output; // Label to display output 
13 private string threadName; // name of the current thread 
15 // RandomLetters constructor
16 public RandomLetters( Label label )
17 {
18 output = label;
19 } // end RandomLetters constructor
21 // delegate that allows method DisplayCharacter to be called
22 // in the thread that creates and maintains the GUI 
23 private delegate void DisplayDelegate( char displayChar ); 
25 // method DisplayCharacter sets the Label's Text property
26 private void DisplayCharacter( char displayChar ) 
27 { 
28  // output character in Label 
29  output.Text = threadName + ": " + displayChar; 
30 } // end method DisplayCharacter 
32 // place random characters in GUI
33 public void GenerateRandomCharacters()
34 {
35 // get name of executing thread 
36 threadName = Thread.CurrentThread.Name;
38 while ( true ) // infinite loop; will be terminated from outside 39 { 40 // sleep for up to 1 second 41 Thread.Sleep( generator.Next( 1001 ) ); 42 43 lock ( this ) // obtain lock 44 { 45 while ( suspended ) // loop until not suspended 46 { 47 Monitor.Wait( this ); // suspend thread execution 48 } // end while 49 } // end lock 50 51 // select random uppercase letter 52 char displayChar = ( char ) ( generator.Next( 26 ) + 65 ); 53 54 // display character on corresponding Label 55 output.Invoke( new DisplayDelegate( DisplayCharacter ), 56 new object[] { displayChar } ); 57 } // end while 58 } // end method GenerateRandomCharacters 59 60 // change the suspended/running state 61 public void Toggle() 62 { 63 suspended = !suspended; // toggle bool controlling state 64 65 // change label color on suspend/resume 66 output.BackColor = suspended ? Color.Red : Color.LightGreen; 67 68 lock ( this ) // obtain lock 69 { 70 if ( !suspended ) // if thread resumed 71 Monitor.Pulse( this ); 72 } // end lock 73 } // end method Toggle 74 } // end class RandomLetters

Figure 15.14. GUIThreads demonstrates multithreading in a GUI application.

(This item is displayed on pages 756 - 757 in the print version)

 1 // Fig. 15.14: GUIThreads.cs
 2 // Demonstrates using threads in a GUI
 3 using System;
 4 using System.Windows.Forms;
 5 using System.Threading;
 7 public partial class GUIThreadsForm : Form
 8 {
 9 public GUIThreadsForm()
10 {
11 InitializeComponent();
12 } // end constructor
14 private RandomLetters letter1; // first RandomLetters object
15 private RandomLetters letter2; // second RandomLetters object
16 private RandomLetters letter3; // third RandomLetters object
18 private void GUIThreadsForm_Load( object sender, EventArgs e )
19 {
20 // create first thread 
21 letter1 = new RandomLetters( thread1Label ); 
22 Thread firstThread = new Thread( 23 new ThreadStart( letter1.GenerateRandomCharacters ) ); 24 firstThread.Name = "Thread 1"; 25 firstThread.Start(); 26 27 // create second thread 28 letter2 = new RandomLetters( thread2Label ); 29 Thread secondThread = new Thread( 30 new ThreadStart( letter2.GenerateRandomCharacters ) ); 31 secondThread.Name = "Thread 2"; 32 secondThread.Start(); 33 34 // create third thread 35 letter3 = new RandomLetters( thread3Label ); 36 Thread thirdThread = new Thread( 37 new ThreadStart( letter3.GenerateRandomCharacters ) ); 38 thirdThread.Name = "Thread 3" ; 39 thirdThread.Start(); 40 } // end method GUIThreadsForm_Load 41 42 // close all threads associated with this application 43 private void GUIThreadsForm_FormClosing( object sender, 44 FormClosingEventArgs e ) 45 { 46 System.Environment.Exit( System.Environment.ExitCode ); 47 } // end method GUIThreadsForm_FormClosing 48 49 // suspend or resume the corresponding thread 50 private void threadCheckBox_CheckedChanged( object sender, 51 EventArgs e ) 52 { 53 if ( sender == thread1CheckBox ) 54 letter1.Toggle(); 55 else if ( sender == thread2CheckBox ) 56 letter2.Toggle(); 57 else if ( sender == thread3CheckBox ) 58 letter3.Toggle(); 59 } // end method threadCheckBox_CheckedChanged 60 } // end class GUIThreadsForm

When the thread awakens, line 43 locks this RandomLetters object, so we can determine whether the thread has been suspended (i.e., the user clicked the corresponding CheckBox). Lines 4548 loop while the bool variable suspended remains true. Line 47 calls Monitor method Wait on this RandomLetters object to temporarily release the lock and place this thread into the WaitSleepJoin state. When this thread is Pulsed (i.e., the user clicks the corresponding CheckBox again), it moves back to the Running state. If suspended is false, the thread resumes execution. If suspended is still true, the loop executes again and the thread re-enters the WaitSleepJoin state.

Line 52 generates a random uppercase character. Lines 5556 call method Invoke, passing to it a new DisplayDelegate containing method DisplayCharacter and a new array of objects that contains the randomly generated letter. Line 23 declares a delegate type named DisplayDelegate, which represents methods that take a char argument and do not return a value. Method DisplayCharacter (lines 2630) meets those requirementsit receives a char parameter named displayChar and does not return a value. The call to Invoke in lines 5556 will cause the UI thread to call DisplayCharacter with the randomly generated letter as the argument. At that time, line 29 will replace the text in the Label associated with this RandomLetters object with the name of the Thread executing this RandomLetters object's GenerateRandomCharacters method and the randomly generated letter.

When the user clicks the CheckBox to the right of a particular Label, the corresponding thread should be suspended (temporarily prevented from executing) or resumed (allowed to continue executing). Suspending and resuming a thread can be implemented by using thread synchronization and Monitor methods Wait and Pulse. Lines 6173 declare method Toggle, which will change the suspended/resumed state of the current thread. Line 63 reverses the value of bool variable suspended. Line 66 changes the background color of the Label by assigning a color to Label property BackColor. If the thread is suspended, the background color will be Color.Red. If the thread is running, the background color will be Color.LightGreen. Method Toggle is called from the event handler in Fig. 15.14, so its tasks will be performed in the UI threadthus, there is no need to use Invoke for line 66. Line 68 locks this RandomLetters object, so we can determine whether the thread should resume execution. If so, line 71 calls method Pulse on this RandomLetters object to alert the thread that was placed in the WaitSleepJoin state by the Wait method call in line 47.

Note that the if statement in line 70 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 45 will enter the while loop, and line 47 will suspend the thread with a call to method Wait.

Class GUIThreads (Fig. 15.14) displays three Labels and three CheckBoxes. A separate thread of execution is associated with each Label and CheckBox pair. Each thread randomly displays letters from the alphabet in its corresponding Label object. Lines 21, 28 and 35 create three new RandomLetters objects. Lines 2223, 2930 and 3637 create three new Threads that will execute the RandomLetters objects' GenerateRandomCharacters methods. Lines 24, 31 and 38 assign each Thread a name, and lines 25, 32 and 39 Start the THReads.

If the user clicks the Suspended CheckBox next to a particular Label, event handler threadCheckBox_CheckedChanged (lines 5059) determines which CheckBox generated the event and calls its associated RandomLetters object's Toggle method to suspend or resume the thread.

Lines 4347 define the GUIThreadsForm_FormClosing event handler, which calls method Exit of class System.Environment with the ExitCode property as as argument. This causes all other threads in this application to terminate. Otherwise, only the UI thread would be terminated when the user closes this application; THRead1, THRead2 and Thread3 would continue executing forever.



    Introduction to Computers, the Internet and Visual C#

    Introduction to the Visual C# 2005 Express Edition IDE

    Introduction to C# Applications

    Introduction to Classes and Objects

    Control Statements: Part 1

    Control Statements: Part 2

    Methods: A Deeper Look


    Classes and Objects: A Deeper Look

    Object-Oriented Programming: Inheritance

    Polymorphism, Interfaces & Operator Overloading

    Exception Handling

    Graphical User Interface Concepts: Part 1

    Graphical User Interface Concepts: Part 2


    Strings, Characters and Regular Expressions

    Graphics and Multimedia

    Files and Streams

    Extensible Markup Language (XML)

    Database, SQL and ADO.NET

    ASP.NET 2.0, Web Forms and Web Controls

    Web Services

    Networking: Streams-Based Sockets and Datagrams

    Searching and Sorting

    Data Structures



    Appendix A. Operator Precedence Chart

    Appendix B. Number Systems

    Appendix C. Using the Visual Studio 2005 Debugger

    Appendix D. ASCII Character Set

    Appendix E. Unicode®

    Appendix F. Introduction to XHTML: Part 1

    Appendix G. Introduction to XHTML: Part 2

    Appendix H. HTML/XHTML Special Characters

    Appendix I. HTML/XHTML Colors

    Appendix J. ATM Case Study Code

    Appendix K. UML 2: Additional Diagram Types

    Appendix L. Simple Types


    Visual C# How to Program
    Visual C# 2005 How to Program (2nd Edition)
    ISBN: 0131525239
    EAN: 2147483647
    Year: 2004
    Pages: 600 © 2008-2020.
    If you may any questions please contact us: