.net使用线程与线程处理

1.线程的创建

   .net是通过Thread类来描述线程的，线程的创建即构造Thread类即可。

    Thread常用的构造函数有两个，分别是：

   Thread(ThreadStart)  与 Thread(ParameterizedThreadStart) 。

   其中：ThreadStart是一个委托，定义如下：public delegate void ThreadStart()

               ParameterizedThreadStart也是一个委托，定义如下：public delegate void ParameterizedThreadStart(Object obj)

    二者的区别是ParameterizedThreadStart是一个能够使用一个object对象作为参数的委托。其中参数通过 Thread.Start(Object para)

   方式进行参数的确定。

    1.1使用ThreadStart创建线程举例：

1. using System;
2. using System.Threading;
4. class Test
5. {
6.     static void Main() 
7.     {
8.         Thread newThread = 
9.             new Thread(new ThreadStart(Work.DoWork));
10.         newThread.Start();
11.     }
12. }
14. class Work 
15. {
16.     Work() {}
18.     public static void DoWork() {}
19. }

当然在使用委托时可以简化使用方式，如：

 Thread newThread=new Thread(Work.DoWork);

 

    1.2使用ParameterizedThreadStart创建线程举例：

1. using System;
2. using System.Threading;
4. public class Work
5. {
6.     public static void Main()
7.     {
8.         // To start a thread using a shared thread procedure, use
9.         // the class name and method name when you create the 
10.         // ParameterizedThreadStart delegate. C# infers the 
11.         // appropriate delegate creation syntax:
12.         //    new ParameterizedThreadStart(Work.DoWork)
13.         //
14.         Thread newThread = new Thread(Work.DoWork);
16.         // Use the overload of the Start method that has a
17.         // parameter of type Object. You can create an object that
18.         // contains several pieces of data, or you can pass any 
19.         // reference type or value type. The following code passes
20.         // the integer value 42.
21.         //
22.         newThread.Start(42);
24.         // To start a thread using an instance method for the thread 
25.         // procedure, use the instance variable and method name when 
26.         // you create the ParameterizedThreadStart delegate. C# infers 
27.         // the appropriate delegate creation syntax:
28.         //    new ParameterizedThreadStart(w.DoMoreWork)
29.         //
30.         Work w = new Work();
31.         newThread = new Thread(w.DoMoreWork);
33.         // Pass an object containing data for the thread.
34.         //
35.         newThread.Start("The answer.");
36.     }
38.     public static void DoWork(object data)
39.     {
40.         Console.WriteLine("Static thread procedure. Data='{0}'",
41.             data);
42.     }
44.     public void DoMoreWork(object data)
45.     {
46.         Console.WriteLine("Instance thread procedure. Data='{0}'",
47.             data);
48.     }
49. }

1.2线程的终止

 

       可以调用Abort方法终止线程。线程是如何终止自己的呢？线程终止的过程是在线程外（比如主线程）调用该线程对象的Abort方法，该方法会使该线程在运行过程中出现一个异常 ThreadAbortException ,该异常可以在线程内被捕捉到。被终止的线程在被Abort以后，不再去执行正常的代码，而是捕获到异常转而执行 catch{}finally{}的代码。这说明，线程并不是立即退出的，而是继续执行一段善后的代码。所以在调用Abort时，最好继续调用Join()函数，让线程执行完善后代码再退出。

      如果被终止的线程正在运行中，调用Abort则会中止后续代码的运行；如果被终止的线程处于 WaitSleepJoin状态，那么该线程会被中断然后中止（即线程被唤醒然后中止）。

1. using System;
2. using System.Threading;
4. class Test
5. {
6.     public static void Main()
7.     {
8.         Thread newThread  = new Thread(new ThreadStart(TestMethod));
9.         newThread.Start();
10.         Thread.Sleep(1000);
12.         // Abort newThread.
13.         Console.WriteLine("Main aborting new thread.");
14.         try
15.        {
16.         newThread.Abort("Information from Main.");
17.        }
18.        catch(ThreadAbortException)
19.        {
20.               Console.WriteLine("main catch the ThreadAbortException");
21.        }
22.         // Wait for the thread to terminate.
23.         newThread.Join();
24.         Console.WriteLine("New thread terminated - Main exiting.");
25.     }
27.     static void TestMethod()
28.     {
29.         try
30.         {
31.             while(true)
32.             {
33.                 Console.WriteLine("New thread running.");
34.                 Thread.Sleep(1000);
35.             }
36.         }
37.         catch(ThreadAbortException abortException)
38.         {
39.             Console.WriteLine((string)abortException.ExceptionState);
40.         }
41.     }
42. }
43. 注：在上述代码中，main函数是无法捕获ThreadAbortException异常的。

1.3线程的阻塞

      引起线程阻塞的方法有静态方法Sleep()，因为是静态方法所以只能由线程自身完成阻塞过程，并且线程立即进入阻塞状态。是一种主动的阻塞。

      Join()则是阻塞调用线程而等待使工作线程运行完毕。

     注意：Thread.CurrentThread.Join()与Sleep()容易产生混淆，二者都是使当前线程阻塞。区别好像是在处理一些非托管的资源时使用 Thread.CurrentThread.Join()而不是Sleep()，MSDN如此解释：“在继续执行标准的 COM 和 SendMessage 消息泵处理期间，阻塞调用线程，直到某个线程终止为止。”

 

1.4线程的唤醒

     使用Abort以及Interrupt都能使处于WaitSleepJoin中的线程产生中断唤醒，区别在于Abort是使线程终止，而Interrupt是使中断一个线程仅仅释放它的当前的（或下一个）等待状态，它并不结束这个线程。

    ThreadInterruptedException 在中断的线程中引发，但要在该线程阻塞之后才引发。如果该线程一直未阻塞，则一直都不会引发该异常，因而该线程可能无需中断就能完成。下面的例子（稍不同于MSDN上写得），可以看出Interrupt的确没有终止线程。

 

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
6. using System.Threading;
8. namespace InterruptTest
9. {
10.     class Program
11.     {
12.         static void Main(string[] args)
13.         {
15.             StayAwake stayAwake = new StayAwake();
16.             Thread newThread =
17.                 new Thread(new ThreadStart(stayAwake.ThreadMethod));
18.             newThread.IsBackground = true;
19.             newThread.Start();
20.             // The following line causes an exception to be thrown 
21.             // in ThreadMethod if newThread is currently blocked
22.             // or becomes blocked in the future.
23.             Thread.CurrentThread.Join(100);
24.             newThread.Interrupt();
25.             Console.WriteLine("Main thread calls Interrupt on newThread.");
27.             // Tell newThread to go to sleep.
28.             //stayAwake.SleepSwitch = true;
29.             // Wait for newThread to end.
30.             newThread.Join();
31.             Console.ReadLine();
32.   
33.         }
34.         
35.     }
36.     class StayAwake
37.     {
38.         bool sleepSwitch = false;
40.         public bool SleepSwitch
41.         {
42.             set { sleepSwitch = value; }
43.         }
45.         public StayAwake() { }
47.         public void ThreadMethod()
48.         {
49.             Console.WriteLine("newThread is executing ThreadMethod.");
51.             while (!sleepSwitch)
52.             {
53.                 try
54.                 {
55.                     Thread.Sleep(1000);
56.                     Console.WriteLine("sleep again");
57.                 }
58.                 catch (ThreadInterruptedException)
59.                 {
60.                     Console.WriteLine("newThread cannot go to sleep - " + "interrupted by main thread.");
61.                 }
62.             }
63.         }
64.     }
66. }