Start()<\/code> method of an instance of the System.Threading.Thread<\/code> class that is initialized with a ThreadStart<\/code> delegate instance pointing to the method that we want to run on the new thread. For example:<\/p>\n\r\n\/\/ Instantiate a ThreadStart delegate pointing to the method\r\n\/\/ to be run asynchronously\r\n\/\/ (in this case, our asynchronous method is called DoStuff)\r\nThreadStart ts = new ThreadStart(DoStuff);\r\n\r\n\/\/ Initialize a new Thread object with this delegate\r\nThread t = new Thread(ts);\r\n\r\n\/\/ Start the method\r\nt.Start();<\/pre>\nOne of the problems with this approach is that the ThreadStart<\/code> delegate is void and parameterless, so this technique can’t be used to run methods that have a return value or parameters. If you’re writing a method to be run asynchronously in this way, you’ll need to design it to match this delegate. If you want to call an existing method in this way, you’ll need to create a new method that is void and parameterless, pass the required data into it (we’ll see how to do this shortly), and then call the existing method from there.<\/p>\nThe thread pool <\/h4>\n
A .NET application has available to it a pool of threads that are managed by the system. When we queue a task to be executed on a thread-pool thread, it will be executed on any free thread taken from the pool. The thread pool is created the first time it is used by an application, and contains by default a maximum of 25 worker threads per processor (this can be changed by calling the unmanaged method CorSetMaxThreads<\/code>, defined in mscoree.h<\/code>). If the maximum number of threads is reached and all threads in the pool are busy when the method is called, a thread will be allocated when one becomes available.<\/p>\nYou can establish the maximum number of thread-pool threads by calling the ThreadPool.GetMaxThreads()<\/code> static method, and you can determine how many threads are currently available by calling the ThreadPool.GetAvailableThreads()<\/code> static method. Both these methods take two output parameters of type int. The first will be populated with the number of worker threads available for background processing and the second the number of additional threads known as completion port threads that can be started for asynchronous I\/O operations.<\/p>\nThe thread pool is best suited for applications that require multiple threads that will execute only for a short time or spend most of their time in the sleeping state, as threads that take a long time will block other tasks. The thread pool allows the system to optimise thread usage for this scenario. Also, because the thread pool is managed by the system, it allows the system to optimise thread usage even with respect to other processes, about which your application knows nothing. Moreover, the thread will quite likely already exist, so there’s no start up overhead.<\/p>\n
Method calls can be queued to the thread pool in a number of ways: using asynchronous delegates, by calling the ThreadPool.QueueUserWorkItem()<\/code> method, or by calling a BeginXxxx()<\/code> method on a built-in class, such as HttpWebRequest.BeginGetResponse()<\/code>. Here we’ll focus on asynchronous delegates.<\/p>\nAsynchronous delegates <\/h4>\n
Probably the easiest way to invoke a method on a thread-pool thread is to call an asynchronous delegate. When our source code is compiled, the compiler generates a class for each delegate type that contains methods called BeginInvoke()<\/code> and EndInvoke()<\/code>. The implementation for these methods is provided by the CLR, and we can call them on any delegate instance. BeginInvoke()<\/code> causes the method represented by delegate to be queued to the thread pool, while EndInvoke()<\/code> blocks the thread on which it is called until the asynchronous method has completed, and allows us to retrieve the return value for that method. The parameters for BeginInvoke()<\/code> are:<\/p>\n\n- Any parameters required for the asynchronous method <\/li>\n
- An
AsyncCallback<\/code> delegate instance that points to the method that will be called when the invoked method terminates <\/li>\n- An object to contain state for the asynchronous operation <\/li>\n<\/ul>\n
BeginInvoke()<\/code> returns an object that implements the IAsyncResult<\/code> interface, which can be used to access the asynchronous delegate instance and hence call EndInvoke()<\/code> to get the return value from the asynchronous method. This IAsyncResult<\/code> implementation is passed into the callback method, so EndInvoke()<\/code> can be called either from the original method, or from the callback method. Note that the callback<\/code> method executes on the thread-pool thread, not the original thread, so in the latter scenario you may need to pass the return value back to the original thread.<\/p>\nThe following very simple console application demonstrates the user of asynchronous delegates. Here we use the technique to execute on a thread-pool thread a static method named Add()<\/code> that returns (as a long<\/code>) the sum of two integers passed in as parameters (after a brief delay to simulate the type of complicated operation that you’d normally want to perform asynchronously). When the method has finished executing, a callback method named PrintResult()<\/code> will be invoked. Like all callback methods for use with asynchronous delegates, this has a return type of void<\/code> and takes a single parameter of type IAsyncResult<\/code>.<\/p>\n\r\nusing System;\r\nusing System.Threading;\r\nusing System.Runtime.Remoting.Messaging;\r\n\r\nnamespace AsyncTest\r\n{\r\n public delegate long AddDelegate(int x, int y);\r\n\r\n class Class1\r\n {\r\n [STAThread]\r\n static void Main(string[] args)\r\n {\r\n int x = 23;\r\n int y = 42;\r\n AddDelegate addDelegate = new AddDelegate(Add);\r\n AsyncCallback ac = new AsyncCallback(PrintResult);\r\n IAsyncResult ar = addDelegate.BeginInvoke(x, y, ac, null);\r\n Console.ReadLine();\r\n }\r\n\r\n static long Add(int x, int y)\r\n {\r\n Thread.Sleep(1000);\r\n return x + y;\r\n }\r\n\r\n static void PrintResult(IAsyncResult ar)\r\n\r\n {\r\n AddDelegate addDelegate = (AddDelegate)\r\n((AsyncResult)ar).AsyncDelegate;\r\n long sum = addDelegate.EndInvoke(ar);\r\n Console.WriteLine(sum);\r\n }\r\n }\r\n}<\/pre>\nThe PrintResult()<\/code> method takes the IAsyncResult<\/code> implementation that the system passes into it when the method is invoked, and casts it to System.Runtime.Remoting.Messaging.AsyncResult<\/code>, which is the actual type of the object. This class has a property named AsyncDelegate<\/code>, which we call to retrieve the delegate instance on which the BeginInvoke()<\/code> call was made. This is returned as an object, so we need to cast it to our delegate type. We can then call its EndInvoke()<\/code> method, passing in the IAsyncResult<\/code> implementation, and this returns the value returned from our asynchronous method call – the sum of the two numbers we wanted to add. All that remains to do is print the result out.<\/p>\nThe Thread class <\/h3>\n
Once we’ve started a new thread, we can manipulate it using the System.Threading.Thread<\/code> class. We can get a reference to an instance of this class representing a specific thread either by starting a thread manually (see the section on ‘Starting a New Thread’ above) or by calling the Thread.CurrentThread<\/code> static property, which returns a Thread<\/code> instance representing the thread on which the call is executed.<\/p>\nThe Thread class provides a number of methods and properties that provide information about the thread and are very useful for asynchronous programming. We won’t look at all of these here, as the details can be seen on MSDN, and we’ll delay looking at some of the functionality until Part 2. We’ve already met the static Sleep()<\/code> method, which blocks the current thread for a set number of milliseconds or for a TimeSpan<\/code> instance. If we specify a value of zero, this will give other threads a chance to execute without actually blocking this one for a set time.<\/p>\nWe can also suspend a thread indefinitely by calling the Suspend()<\/code> method, and restart it by calling Resume()<\/code>. If a thread is already suspended when Suspend()<\/code> is called, the call is ignored, but if it isn’t in the suspended state when Resume()<\/code> is called, a ThreadStateException<\/code> will be thrown.<\/p>\nThe ThreadState property <\/h3>\n
For this reason, we need to be able to examine the current state of a thread, and this is available through the ThreadState<\/code> property. This returns a bitmasked ThreadState<\/code> enumeration value, consisting of a combination of the following values:<\/p>\n\n\n\n\nName<\/b><\/p>\n<\/td>\n
\nDescription<\/b><\/p>\n<\/td>\n
\nValue<\/b><\/p>\n<\/td>\n<\/tr>\n<\/thead>\n\n\n\nRunning<\/code><\/p>\n<\/td>\n\nThe thread is running.<\/p>\n<\/td>\n
\n0<\/p>\n<\/td>\n<\/tr>\n
\n\nStopRequested<\/code><\/p>\n<\/td>\n\nThe thread is being requested to stop (internal use only).<\/p>\n<\/td>\n
\n1<\/p>\n<\/td>\n<\/tr>\n
\n\nSuspendRequested<\/code><\/p>\n<\/td>\n\nA request has been made to suspend the thread.<\/p>\n<\/td>\n
\n2<\/p>\n<\/td>\n<\/tr>\n
\n\nBackground<\/code><\/p>\n<\/td>\n\nThe thread is a background thread.<\/p>\n<\/td>\n
\n4<\/p>\n<\/td>\n<\/tr>\n
\n\nUnstarted<\/code><\/p>\n<\/td>\n\nThe Thread.Start()<\/code> method has not yet been called on the thread.<\/p>\n<\/td>\n\n8<\/p>\n<\/td>\n<\/tr>\n
\n\nStopped<\/code><\/p>\n<\/td>\n\nThe thread has stopped.<\/p>\n<\/td>\n
\n16<\/p>\n<\/td>\n<\/tr>\n
\n\nWaitSleepJoin<\/code><\/p>\n<\/td>\n\nThe thread is blocked because one of the Wait()<\/code>, Sleep()<\/code> or Join()<\/code> methods has been called.<\/p>\n<\/td>\n\n32<\/p>\n<\/td>\n<\/tr>\n
\n\nSuspended<\/code><\/p>\n<\/td>\n\nThe thread has been suspended.<\/p>\n<\/td>\n
\n64<\/p>\n<\/td>\n<\/tr>\n
\n\nAbortRequested<\/code><\/p>\n<\/td>\n\nA ThreadAbortException<\/code> is pending on the thread.<\/p>\n<\/td>\n\n128<\/p>\n<\/td>\n<\/tr>\n
\n\nAborted<\/code><\/p>\n<\/td>\n\nA ThreadAbortException<\/code> has been thrown on the thread and the thread is in the Stopped<\/code> state.<\/p>\n<\/td>\n\n256<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Because this returned value is a bitmask, we need to perform a bitwase AND<\/code> operation on the value to determine whether it includes a specific value. For example, to see if the current thread is a background thread, we would use the following code:<\/p>\n\r\n\/\/ Get a reference to the current thread\r\nThread t = Thread.CurrentThread;\r\n\r\n\/\/ Check whether the ThreadState includes the Background value\r\nif ((t.ThreadState & ThreadState.Background) == ThreadState.Background)\r\n{\r\n \/\/ Thread is a background thread\r\n}<\/pre>\nAborting threads <\/h3>\n
To abort a thread, we can call the Abort()<\/code> method on the thread we wish to terminate. This causes the CLR to throw a ThreadAbortException<\/code> on that thread. This exception can of course be caught and handled just like any other .NET exception object. We can even stop the abort by calling the Thread.ResetAbort()<\/code> static method. Note that the exception must be handled on the same thread that it’s thrown on – it won’t be bubbled up to the thread from which the asynchronous method call was made. You therefore need to be very careful when aborting threads from a separate thread: you need to make sure that aborting the thread won’t cause data to be lost or corrupted, so it’s a good idea to catch ThreadAbortException<\/code>s in any method that may be executing if a thread is to be aborted in this way.<\/p>\nPassing data between threads <\/h3>\n
We saw earlier that when we create a new Thread<\/code> object, the delegate we pass into the constructor must be parameterless and void<\/code>. This means that any data passed between the threads must be stored in either static fields or fields of a class instance. The following example illustrates this (and also potentially indicates the sort of bugs that can occur in multi-threaded applications). The class for the example has a static integer field called count<\/code>. This is used in a static method named Start()<\/code>, which reads and increments this static value, and displays it together with the name of the thread on which the method is executing, before sleeping to allow other threads to execute. This entire procedure is then repeated four times. The Main()<\/code> method for the example calls this method asynchronously five times, each time giving the thread a different name based:<\/p>\n\r\nusing System;\r\nusing System.Threading;\r\n\r\nnamespace AsyncTest2\r\n{\r\n class Class1\r\n {\r\n public static int count = 0;\r\n\r\n [STAThread]\r\n static void Main(string[] args)\r\n {\r\n for (int i = 1; i < 6; i++)\r\n {\r\n ThreadStart tsDelegate = new ThreadStart(Start);\r\n Thread t = new Thread(tsDelegate);\r\n t.Name = \u201cThread \u201d + i;\r\n t.Start();\r\n }\r\n }\r\n\r\n public static void Start()\r\n {\r\n for (int i = 0; i < 5; i++)\r\n {\r\n Class1.count++;\r\n Console.WriteLine(\u201c{0} ({1})\u201d, count, Thread.CurrentThread.Name);\r\n Thread.Sleep(0);\r\n }\r\n }\r\n }\r\n}<\/pre>\n\r\n1 (Thread 1)\r\n2 (Thread 2)\r\n3 (Thread 3)\r\n4 (Thread 4)\r\n5 (Thread 5)\r\n6 (Thread 1)\r\n\r\n\u2026\r\n25 (Thread 5)<\/pre>\nSynchronization and the lock keyword <\/h3>\n
The problem with this code is that we don’t know when the operating system will switch execution from one thread to another, so it’s perfectly feasible that between reading the value of count and incrementing it, another thread will have read and incremented the value, so the value of count will in effect only be incremented once instead of twice. To see this happen, change the Start()<\/code> method so that the call to Thread.Sleep()<\/code> occurs between reading and incrementing the value of count:<\/p>\n\r\n public static void Start() {\r\n \tfor (int i = 0; i < 5; i++) {\r\n \t\tint temp = Class1.count;\r\n \t\tThread.Sleep(0);\r\n \t\tClass1.count = temp + 1;\r\n \t\tConsole.WriteLine(\"{0} ({1})\", count, Thread.CurrentThread.Name);\r\n \t}\r\n }<\/pre>\n1 (Thread 5)\r\n1 (Thread 4)\r\n1 (Thread 3)\r\n1 (Thread 2)\r\n1 (Thread 1)\r\n2 (Thread 5)\r\netc...<\/pre>\nAlthough we’ve deliberately made the bug obvious and easy to replicate in this case, this type of error can frequently lead to very subtle bugs (called race conditions<\/b>) that are extremely difficult to reproduce and track down. For this reason, it’s important to ensure that multiple threads don’t access the same piece of data at the same time, particularly when changing it. This process of controlling how multiple threads interact with each other is known as synchronization. We’ll look at .NET’s synchronization features in Part 2, but for the moment we’ll introduce the most common synchronization device – the C# lock<\/code> keyword ( SyncLock<\/code> in VB).<\/p>\nThe lock keyword places a lock known as a monitor on a specific section of code (called a critical section<\/b>), using a particular object. Only one thread can have a monitor lock on any particular object at the same time, so if a second thread requests a lock on the same object, it will be blocked until the first thread exits the protected code section and releases the lock. The compiled code produced by the lock<\/code> keyword releases the lock within a finally<\/code> section, so this ensures that the lock is always released, even if an exception occurs in the protected code.<\/p>\nThe object used for the lock must be an instance of a reference type. The most common object is the current instance of the class that the code is running in, by using the this<\/code> keyword, or (if the code is in a static method) the Type<\/code> object for the class. For example:<\/p>\nlock (this){ \/\/ Code here is protected, and no other thread can execute code \/\/ that's locked with this object}<\/pre>\nlock (typeof(Class1)){ \/\/ No other thread can execute code locked with the Class1 Type object}<\/pre>\n\r\n public static void Start()\r\n {\r\n for (int i = 0; i < 5; i++)\r\n {\r\n lock (typeof(Class1))\r\n {\r\n int temp = Class1.count;\r\n Thread.Sleep(0);\r\n Class1.count = temp + 1;\r\n }\r\n Console.WriteLine(\u201c{0} ({1})\u201d, count, Thread.CurrentThread.Name);\r\n }\r\n }<\/pre>\n\r\n1 (Thread 1)\r\n2 (Thread 2)\r\n3 (Thread 2)\r\netc\u2026<\/pre>\nA multi-threaded Windows Forms application <\/h2>\n
To illustrate working with threads in .NET, we’ve provided a simple application that demonstrates some of the functionality available. The application displays a number of coloured strings scrolling across a panel at different angles and different speeds. The movement of each string is controlled on a separate, manually-started thread. The user can change the speed and angle of existing strings, and can also start new threads, and abort, pause or resume existing threads. The interface appears as in the screenshot below:<\/p>\n
![\"248-multithreading.jpg\"](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/imported\/248-multithreading.jpg\")
<\/p>\n
Each string is represented by an instance of a class called DrawString<\/code>. This class contains information about the colour of the string, its current position, speed and angle, and whether or not it’s the selected string that the user can manipulate. It will also contain references to the GDI+ Brush object used to draw the string, the parent Windows control on which it will be painted, and the thread on which it’s executing:<\/p>\n\r\npublic class DrawString : IDisposable\r\n{\r\n private string text;\r\n private float angle;\r\n private float x;\r\n private float y;\r\n private bool selected;\r\n private Color colour;\r\n private int speed;\r\n private SolidBrush brush;\r\n private Control ctrl;\r\n private Thread thread;<\/pre>\nWhen a DrawString<\/code> object is instantiated, we store the initial details of its appearance and position in the class’s fields, together with the reference to the parent Windows control. Whenever a new string is created, it will automatically be set as the selected string, so we set the selected<\/code> field to true<\/code>. We also create a GDI+ SolidBrush<\/code> object of the correct colour, which will be used when we draw the control:<\/p>\n\r\n public DrawString(string text, Color colour, float angle, float x, float y, int speed, Control ctrl) {\r\n \tthis.text = text;\r\n \tthis.angle = angle;\r\n \tthis.x = x;\r\n \tthis.y = y;\r\n \tthis.colour = colour;\r\n \tthis.speed = speed;\r\n \tthis.ctrl = ctrl;\r\n \tselected = true;\r\n \tbrush = new SolidBrush(colour);\r\n }<\/pre>\nIn order to access these fields from the Windows Form, we’ll create public properties. The angle and speed can be changed by the user, so these are read-write properties. We’ll also use set the Selected<\/code> property to read-write, as this will need to be changed when a new string is selected. The other properties are all read-only:<\/p>\n\r\n public string Text {\r\n \tget {\r\n \t\treturn text;\r\n \t}\r\n }\r\n public float Angle {\r\n \tget {\r\n \t\treturn angle;\r\n \t}\r\n \tset {\r\n \t\tangle = value;\r\n \t}\r\n }\r\n public float X {\r\n \tget {\r\n \t\treturn x;\r\n \t}\r\n }\r\n public float Y {\r\n \tget {\r\n \t\treturn y;\r\n \t}\r\n }\r\n public Color Colour {\r\n \tget {\r\n \t\treturn colour;\r\n \t}\r\n }\r\n public SolidBrush Brush {\r\n \tget {\r\n \t\treturn brush;\r\n \t}\r\n }\r\n public int Speed {\r\n \tget {\r\n \t\treturn speed;\r\n \t}\r\n \tset {\r\n \t\tspeed = value;\r\n \t}\r\n }\r\n public bool Selected {\r\n \tget {\r\n \t\treturn selected;\r\n \t}\r\n \tset {\r\n \t\tselected = value;\r\n \t}\r\n }\r\n public Thread Thread {\r\n \tget {\r\n \t\treturn thread;\r\n \t}\r\n }<\/pre>\nThe movement of the string across the panel is controlled by a method named Start()<\/code>. This is the method that is called on a new thread, and so we start by storing a reference to the Thread<\/code> object for the current thread. This will be used to pause, restart and abort the thread from the main application thread. To prevent a ThreadAbortException<\/code> bubbling up to the main thread if the thread is aborted, we wrap the code for this method in a try<\/code> block and catch any ThreadAbortExceptions<\/code>.<\/p>\nThe bulk of the method consists of an infinite loop; on every iteration of this loop, we call Thread.Sleep()<\/code> to pause the thread for a time depending on the speed of the string, and then increase the X and Y coordinates of the string according to the angle in which it’s moving. When one edge of the panel is reached, the X or Y coordinate is set to the opposite edge. Note that we lock the thread before altering the X and Y values. This is because the X and Y values are read from the main thread when the panel is drawn, so we need to ensure that the values aren’t read while they’re in the process of being rewritten. Once the values have been updated, we refresh the control so that the string will appear in its new position.<\/p>\n\r\n public void Start() {\r\n \ttry {\r\n \t\tthread = Thread.CurrentThread;\r\n \t\tfor (;;) {\r\n \t\t\tThread.Sleep(new TimeSpan((11 - speed) * 100000));\r\n \t\t\tlock(this) {\r\n \t\t\t\tx += (float) Math.Cos(Math.PI * angle \/ 180);\r\n \t\t\t\ty += (float) Math.Sin(Math.PI * angle \/ 180);\r\n \t\t\t\tif (x >= ctrl.Width) x = x - ctrl.Width;\r\n \t\t\t\tif (y >= ctrl.Height) y = y - ctrl.Height;\r\n \t\t\t\tif (x < 0) x = x + ctrl.Width;\r\n \t\t\t\tif (y < 0) y = y + ctrl.Height;\r\n \t\t\t}\r\n \t\t\tctrl.Refresh();\r\n \t\t}\r\n \t} catch (ThreadAbortException) {}\r\n }<\/pre>\nThe last method of the DrawString<\/code> class is the Dispose()<\/code> method. Here we simply dispose of the Brush<\/code> object:<\/p>\n public void Dispose() {\r\n \tbrush.Dispose();\r\n }\r\n }\r\n <\/pre>\nWe can now turn to the MultithreadExample<\/code> class that represents our Windows form. We won’t go through all the UI code for this class, as much of it is autogenerated by VS, but instead highlight the relevant added code.<\/p>\nWe add four private fields to the form class: an ArrayList<\/code> that contains all the DrawString<\/code> instances; a reference to the currently selected DrawString<\/code>; and two Font<\/code> objects. The first of these is used to draw the selected string, and the other is used for all other strings:<\/p>\n\r\nprivate ArrayList drawStrings;\r\nprivate DrawString selectedString;\r\nprivate Font boldFont = new Font(\"Arial\", 11, FontStyle.Bold);\r\nprivate Font normalFont = new Font(\"Arial\", 10);<\/pre>\nIn the constructor for the form, we have the usual call to InitializeComponent()<\/code>, and then create the drawStrings<\/code> ArrayList<\/code>. Next, we start off a string to get things going. First we calculate a random colour, speed, angle and position for the string, and pass these into the DrawString<\/code> constructor. We then add the new DrawString<\/code> object to the drawStrings<\/code> array and set it as the selected string. Finally, we need to execute the DrawString<\/code> object’s Start()<\/code> method on a new thread. To do this, we create a new ThreadStart<\/code> delegate instance that points to this method, and use that to instantiate a new Thread object. We want the application to terminate once the form is closed and the main thread has finished, so all the DrawString<\/code> threads must be background threads. Therefore, we set the Thread’s IsBackground<\/code> property to true<\/code> before we call its Start()<\/code> method to start the execution and set the string moving.<\/p>\n\r\npublic MultithreadExample() {\r\n\tInitializeComponent();\r\n\tdrawStrings = new ArrayList();\r\n\tRandom rnd = new Random();\r\n\tint speed = rnd.Next(10) + 1;\r\n\tint x = rnd.Next(panel1.Width);\r\n\tint y = rnd.Next(panel1.Height);\r\n\tint angle = rnd.Next(360);\r\n\tint red = rnd.Next(256);\r\n\tint green = rnd.Next(256);\r\n\tint blue = rnd.Next(256);\r\n\tDrawString ds = new DrawString(\"First string\", Color.FromArgb(red, green, blue), angle, x, y, speed, panel1);\r\n\tdrawStrings.Add(ds);\r\n\tselectedString = ds;\r\n\tThreadStart startDelegate = new ThreadStart(ds.Start);\r\n\tThread t = new Thread(startDelegate);\r\n\tt.IsBackground = true;\r\n\tt.Start();\r\n}<\/pre>\nThe code to draw the strings is placed in the panel1_Paint()<\/code> method, which is called whenever the panel control is redrawn. This has little to do with asynchronous processing, except that we lock each DrawString<\/code> object before reading its properties to ensure data integrity, so we’ll just glance over it quickly. We get the GDI+ Graphics<\/code> object from the PaintEventArgs<\/code> object that is passed into the method. For each DrawString<\/code> object in the drawStrings<\/code> array, we transform the (0, 0) coordinates of the control to the coordinates of the DrawString<\/code> object, rotate the drawing direction to the required angle, and then draw the string using the information in the DrawString<\/code> object. Finally, we reset the coordinates and rotation of the control, so that the next string won’t be positioned relative to this one:<\/p>\n\r\nprivate void panel1_Paint(object sender,\r\nSystem.Windows.Forms.PaintEventArgs e)\r\n{\r\n Graphics dc = e.Graphics;\r\n StringFormat format = new StringFormat(StringFormat.GenericTypographic);\r\n foreach (DrawString ds in drawStrings)\r\n {\r\n lock (ds)\r\n {\r\n dc.TranslateTransform(ds.X, ds.Y);\r\n dc.RotateTransform(ds.Angle);\r\n dc.DrawString(ds.Text, ds.Selected ? boldFont : normalFont,\r\nds.Brush, 0, 0, format);\r\n dc.ResetTransform();\r\n }\r\n }\r\n}<\/pre>\nOne important point to note is that this method is always called by the CLR on the main application thread for the Windows form. The main thread for a Windows Forms application serves as the user interface thread, and is used to handle user input and to update the UI. Updating the UI from other threads is not allowed. All updates to the UI using GDI+ should be made from the method for the control’s Paint<\/code> event, or its overwritten OnPaint()<\/code> method. These methods will be called on the UI thread as necessary by the CLR.<\/p>\nWhen a new string is created by the user, we instantiate a new DrawString<\/code> object based on the information supplied by the user. The code to start the new string is identical to that which we saw when we created the first string when the application started:<\/p>\n\r\n private void button1_Click(object sender, System.EventArgs e) {\r\n\tif (textBox1.Text.Trim() == \"\") return;\r\n\tif (selectedString != null) selectedString.Selected = false;\r\n\tDrawString ds = new DrawString(textBox1.Text, label7.BackColor, (float) numericUpDown1.Value, (float) numericUpDown2.Value, (float) numericUpDown3.Value, (int) numericUpDown4.Value, panel1);\r\n\tselectedString = ds;\r\n\tdrawStrings.Add(ds);\r\n\tpanel1.Refresh();\r\n\tThreadStart startDelegate = new ThreadStart(ds.Start);\r\n\tThread t = new Thread(startDelegate);\r\n\tt.IsBackground = true;\r\n\tt.Start();\r\n}<\/pre>\n\r\nprivate void MultithreadExample_KeyUp(object sender, System.Windows.Forms.KeyEventArgs e) {\r\n\t\tif (selectedString == null) return;\r\n\t\tKeys keyPress = e.KeyCode;\r\n\t\tswitch (keyPress) {<\/pre>\nIf the F1 or F2 key was pressed, we will increase or decrease the speed of the string’s movement by modifying its Speed<\/code> property (up to a maximum of 10, from a minimum of 1). We acquire a lock on the selected DrawString<\/code> object to ensure the data integrity of the speed:<\/p>\n\r\n case (Keys.F1):\r\n \t{\r\n \t\tlock(selectedString) {\r\n \t\t\tif (selectedString.Speed < 10) selectedString.Speed++;\r\n \t\t}\r\n \t\tbreak;\r\n \t}\r\n case (Keys.F2):\r\n \t{\r\n \t\tlock(selectedString) {\r\n \t\t\tif (selectedString.Speed > 1) selectedString.Speed--;\r\n \t\t}\r\n \t\tbreak;\r\n \t}<\/pre>\nIf F3 or F4 is pressed, we increase or decrease the angle of the string by 10 degrees, and then refresh the display. Again, we acquire a lock on the selected DrawString<\/code> object:<\/p>\n\r\n case (Keys.F3):\r\n \t{\r\n \t\tlock(selectedString) {\r\n \t\t\tselectedString.Angle -= 10;\r\n \t\t\tif (selectedString.Angle < 0) selectedString.Angle += 360;\r\n \t\t}\r\n \t\tpanel1.Refresh();\r\n \t\tbreak;\r\n \t}\r\n case (Keys.F4):\r\n \t{\r\n \t\tlock(selectedString) {\r\n \t\t\tselectedString.Angle += 10;\r\n \t\t\tif (selectedString.Angle >= 360) selectedString.Angle -= 360;\r\n \t\t}\r\n \t\tpanel1.Refresh();\r\n \t\tbreak;\r\n \t}<\/pre>\nWhen the user presses F5, we deselect the current DrawString<\/code> object, and move the selection to the next item in the drawStrings<\/code> array. We get the index of the currently selected item in the array, and increment it; if the selected item was the last, we move back to the beginning (position 0). Then we set the Selected<\/code> property of the originally selected DrawString<\/code> object to false<\/code>, set the selectedString<\/code> field to refer to the new string, and set its Selected<\/code> property to true<\/code>. Finally we refresh the display so that the user will be able to see the new string has been selected:<\/p>\n\r\n case (Keys.F5):\r\n \t{\r\n \t\tint index = drawStrings.IndexOf(selectedString);\r\n \t\tif (++index > drawStrings.Count - 1) index = 0;lock(selectedString) {\r\n \t\t\tselectedString.Selected = false;\r\n \t\t}\r\n \t\tselectedString = (DrawString) drawStrings[index];lock(selectedString) {\r\n \t\t\tselectedString.Selected = true;\r\n \t\t}\r\n \t\tpanel1.Refresh();\r\n \t\tbreak;\r\n \t}<\/pre>\nIf the user presses F6, we need to abort the thread for the selected string, remove the DrawString<\/code> object from the drawStrings<\/code> array, and move the selection to the next string. Before aborting the thread, we need to check first that it’s not in the suspended state, as trying to abort a suspended thread generates an exception. If it is, we resume the thread. Then we abort the thread by calling the Abort()<\/code> method of the Thread<\/code> object exposed through the DrawString<\/code>‘s Thread<\/code> property. We don’t need to catch the