.NET中线程的生命周期

当一个线程计划执行时它可以经过几个状态，包括未开始，活跃，睡眠，等等。线程类包含几个允许你启动、停止、恢复、退出、暂停以及等待一个线程的方法。我们可以使用ThreadState属性来获取线程的当前状态，状态值可能是ThreadState枚举中的一个：

网页设计是网站建设的前奏，好的网页设计更深度的剖析产品和设计风格定位，结合最新的网页设计流行趋势，与WVI应用标准，设计出具企业表现力，大器而深稳的网站界面设。创新互联公司公司2013年成立,是成都网站建设公司:提供企业网站设计,品牌网站建设,营销型企业网站建设方案,成都响应式网站建设,成都微信小程序,专业建站公司做网站。

Aborted - 线程当前处理停止状态，但是不一定已经执行完。

AbortRequested – 已经调用Abort() 方法但是线程还没有接收到将试图终止线程的System.Threading.ThreadAbortexception。虽然线程还没有停止，但是马上就会。

Background - 线程在后台执行。

Running - 线程已经启动而且没有被阻塞。

Stopped - 线程已经完成了所有指令并停止了。

StopRequested - 请求线程停止。

Suspend - 线程已经被挂起。

SuspendRequested - 请求挂起线程。

Unstarted - 线程还没有调用Start()方法之前。

WaitSleepJoin - 调用Wait(), Sleep() 或 Join() 方法后处理阻塞状态的线程。

图3 显示了一个线程的生命周期。

图3

在这部分，我们将讨论线程的生命周期

让一个线程进入睡眠状态

当我们创建一个线程后，我们需要调用线程对象的Start()方法来调度那个线程。在这时，CLR将会为作为构造函数参数传递给线程对象的方法地址分配一个时间片。一旦线程开始执行，它就可以在操作系统处理其他线程时回到睡眠状态或者退出状态。我们可以使用线程类的Sleep()方法让一个线程进入睡眠状态。如果你正在等待一个资源并且你想在稍后继续尝试访问这个资源时，Sleep()方法是很重要的。举个例子，假设你的程序由于无法访问需要的资源而导致其不能继续执行时，你可能想要在几毫秒之后尝试继续访问资源，在这种情况下让线程在再次尝试访问资源之前睡眠一段时间是一个很好的方式。

Sleep()方法有两种重载方式。第一种重载方法有一个整型参数，并会按照指定的毫秒时间暂停线程执行。例如，如果你向线程传递值100，那么线程将会暂停100毫秒。这个方法将会让线程进入WaitSleepJoin状态。让我们看一个例子，thread_sleep2.cs:

 
 
 
 
      
  
  
  
  1. /*************************************  
    2.   
  
  
  
  2. 　　/* Copyright (c) 2012 Daniel Dong  
    3.   
  
  
  
  3. 　　*  
    4.   
  
  
  
  4. 　　* Author：Daniel Dong  
    5.   
  
  
  
  5. 　　* Blog： www.cnblogs.com/danielWise  
    6.   
  
  
  
  6. 　　* Email： guofoo@163.com  
    7.   
  
  
  
  7. 　　*  
    8.   
  
  
  
  8. 　　*/ 
    9.   
  
  
  
  9. 　　using System;  
    10.   
  
  
  
  10. 　　using System.Collections.Generic;  
    11.   
  
  
  
  11. 　　using System.Text;  
    12.   
  
  
  
  12. 　　using System.Threading;  
    13.   
  
  
  
  13. 　　namespace SimpleThread  
    14.   
  
  
  
  14. 　　{  
    15.   
  
  
  
  15. 　　public class ThreadSleep  
    16.   
  
  
  
  16. 　　{  
    17.   
  
  
  
  17. 　　public static Thread worker;  
    18.   
  
  
  
  18. 　　public static Thread worker2;  
    19.   
  
  
  
  19. 　　public static void Main()  
    20.   
  
  
  
  20. 　　{  
    21.   
  
  
  
  21. 　　Console.WriteLine("Entering the void Main!");  
    22.   
  
  
  
  22. 　　worker = new Thread(new ThreadStart(Counter));  
    23.   
  
  
  
  23. 　　worker2 = new Thread(new ThreadStart(Counter2));  
    24.   
  
  
  
  24. 　　//Make the worker2 Object as highest priority  
    25.   
  
  
  
  25. 　　worker2.Priority = ThreadPriority.Highest;  
    26.   
  
  
  
  26. 　　worker.Start();  
    27.   
  
  
  
  27. worker2.Start();  
    28.   
  
  
  
  28. 　　Console.WriteLine("Exiting the void Main!");  
    29.   
  
  
  
  29. 　　Console.ReadLine();  
    30.   
  
  
  
  30. 　　}  
    31.   
  
  
  
  31. 　public static void Counter()  
    32.   
  
  
  
  32. 　　{  
    33.   
  
  
  
  33. 　　Console.WriteLine("Entering Counter");  
    34.   
  
  
  
  34. 　　for (int i = 1; i <50; i++)  
    35.   
  
  
  
  35. 　　{  
    36.   
  
  
  
  36. 　　Console.Write(i + " ");  
    37.   
  
  
  
  37. 　　if (i == 10)  
    38.   
  
  
  
  38. 　　{  
    39.   
  
  
  
  39. 　　Console.WriteLine();  
    40.   
  
  
  
  40. 　　Thread.Sleep(1000);  
    41.   
  
  
  
  41. 　　}  
    42.   
  
  
  
  42. 　　}  
    43.   
  
  
  
  43. 　　Console.WriteLine("Exiting Counter");  
    44.   
  
  
  
  44. 　　}  
    45.   
  
  
  
  45. 　　public static void Counter2()  
    46.   
  
  
  
  46. 　　{  
    47.   
  
  
  
  47. 　　Console.WriteLine("Entering Counter2");  
    48.   
  
  
  
  48. 　　for (int i = 51; i <100; i++)  
    49.   
  
  
  
  49. 　　{  
    50.   
  
  
  
  50. 　　Console.Write(i + " ");  
    51.   
  
  
  
  51. 　　if (i == 70)  
    52.   
  
  
  
  52. 　　{  
    53.   
  
  
  
  53. 　　Console.WriteLine();  
    54.   
  
  
  
  54. 　　Thread.Sleep(5000);  
    55.   
  
  
  
  55. 　}  
    56.   
  
  
  
  56. 　　}  
    57.   
  
  
  
  57. 　　Console.WriteLine("Exiting Counter2");  
    58.   
  
  
  
  58. 　　}  
    59.   
  
  
  
  59. 　　}  
    60.   
  
  
  
  60. 　　} 
    61.

Counter()方法从1到50计数，当到达10以后睡眠1000毫秒。Counter2()方法从51~100计数，当到达70时睡眠5000毫秒。下面是输出结果：

注：以上是在多核CPU下运行的结果，单核CPU 执行情况可能与上图有所出入。

第二种重载方法有一个TimeSpan类型参数，当前线程会按照TimeSpan的值暂停一段时间。TimeSpan是System命名空间中的一个类。TimeSpan有一些很有用的属性并会返回基于时钟时间间隔。

我们可以使用FromSeconds()和FromMinutes()来确定睡眠时间。下面是一个例子，thread_sleep3.cs:

 
 
 
 
      
  
  
  
  1. 　　public static void Counter()  
    2.   
  
  
  
  2. 　　{  
    3.   
  
  
  
  3. 　　Console.WriteLine("Entering Counter");  
    4.   
  
  
  
  4. 　　for (int i = 1; i <50; i++)  
    5.   
  
  
  
  5. 　　{  
    6.   
  
  
  
  6. 　　Console.Write(i + " ");  
    7.   
  
  
  
  7. 　　if (i == 10)  
    8.   
  
  
  
  8. 　　{  
    9.   
  
  
  
  9. 　　Console.WriteLine();  
    10.   
  
  
  
  10. 　　Thread.Sleep(TimeSpan.FromSeconds(1));  
    11.   
  
  
  
  11. 　}  
    12.   
  
  
  
  12. 　　}  
    13.   
  
  
  
  13. 　　Console.WriteLine("Exiting Counter");  
    14.   
  
  
  
  14. 　　}  
    15.   
  
  
  
  15. 　　public static void Counter2()  
    16.   
  
  
  
  16. 　　{  
    17.   
  
  
  
  17. 　　Console.WriteLine("Entering Counter2");  
    18.   
  
  
  
  18. 　　for (int i = 51; i <100; i++)  
    19.   
  
  
  
  19. 　　{  
    20.   
  
  
  
  20. 　Console.Write(i + " ");  
    21.   
  
  
  
  21. 　　if (i == 70)  
    22.   
  
  
  
  22. 　　{  
    23.   
  
  
  
  23. 　　Console.WriteLine();  
    24.   
  
  
  
  24. 　　Thread.Sleep(TimeSpan.FromSeconds(5));  
    25.   
  
  
  
  25. 　　}  
    26.   
  
  
  
  26. 　　}  
    27.   
  
  
  
  27. 　　Console.WriteLine("Exiting Counter2");  
    28.   
  
  
  
  28. 　　} 
    29.

输出结果与thread_sleep2类似。

中断一个线程

当让一个线程睡眠时，它实际会进入WaitSleepJoin状态。如果线程处理睡眠状态，那么在它超时退出之前唯一可以唤醒线程的方式是使用Interrupt()方法。Interrupt()方法将让线程回到调度队列中去。让我们看一个例子，thread_interrupt.cs:

 
 
 
 
      
  
  
  
  1. 　　/*************************************  
    2.   
  
  
  
  2. 　　/* Copyright (c) 2012 Daniel Dong  
    3.   
  
  
  
  3. 　　*  
    4.   
  
  
  
  4. 　　* Author：Daniel Dong  
    5.   
  
  
  
  5. 　　* Blog： www.cnblogs.com/danielWise  
    6.   
  
  
  
  6. 　　* Email： guofoo@163.com  
    7.   
  
  
  
  7. 　　*  
    8.   
  
  
  
  8. 　　*/ 
    9.   
  
  
  
  9. 　　using System;  
    10.   
  
  
  
  10. 　　using System.Collections.Generic;  
    11.   
  
  
  
  11. 　　using System.Text;  
    12.   
  
  
  
  12. 　　using System.Threading;  
    13.   
  
  
  
  13. 　namespace SimpleThread  
    14.   
  
  
  
  14. 　　{  
    15.   
  
  
  
  15. 　　public class Interrupt  
    16.   
  
  
  
  16. 　　{  
    17.   
  
  
  
  17. 　　public static Thread sleeper;  
    18.   
  
  
  
  18. 　　public static Thread worker;  
    19.   
  
  
  
  19. 　　public static void Main()  
    20.   
  
  
  
  20. 　　{  
    21.   
  
  
  
  21. 　　Console.WriteLine("Entering the void Main!");  
    22.   
  
  
  
  22. 　　sleeper = new Thread(new ThreadStart(SleepingThread));  
    23.   
  
  
  
  23. 　　worker = new Thread(new ThreadStart(AwakeThread));  
    24.   
  
  
  
  24. 　　sleeper.Start();  
    25.   
  
  
  
  25. 　　worker.Start();  
    26.   
  
  
  
  26. 　　Console.WriteLine("Exiting the void Main!");  
    27.   
  
  
  
  27. 　　Console.ReadLine();  
    28.   
  
  
  
  28. 　　}  
    29.   
  
  
  
  29. 　public static void SleepingThread()  
    30.   
  
  
  
  30. 　　{  
    31.   
  
  
  
  31. 　　for (int i = 1; i <50; i++)  
    32.   
  
  
  
  32. 　　{  
    33.   
  
  
  
  33. 　　Console.Write(i + " ");  
    34.   
  
  
  
  34. 　　if (i == 10 || i == 20 || i == 30)  
    35.   
  
  
  
  35. 　　{  
    36.   
  
  
  
  36. 　　Console.WriteLine("Going to sleep at: " + i);  
    37.   
  
  
  
  37. 　　try 
    38.   
  
  
  
  38. 　　{  
    39.   
  
  
  
  39. 　　Thread.Sleep(20);  
    40.   
  
  
  
  40. 　　}  
    41.   
  
  
  
  41. 　　catch (ThreadInterruptedException ex)  
    42.   
  
  
  
  42. 　　{  
    43.   
  
  
  
  43. 　　Console.WriteLine(ex.Message);  
    44.   
  
  
  
  44. 　　}  
    45.   
  
  
  
  45. 　}  
    46.   
  
  
  
  46. 　　}  
    47.   
  
  
  
  47. 　　}  
    48.   
  
  
  
  48. 　　public static void AwakeThread()  
    49.   
  
  
  
  49. 　　{  
    50.   
  
  
  
  50. 　　for (int i = 51; i <100; i++)  
    51.   
  
  
  
  51. 　　{  
    52.   
  
  
  
  52. 　　Console.Write(i + " ");  
    53.   
  
  
  
  53. 　　if (sleeper.ThreadState == ThreadState.WaitSleepJoin)  
    54.   
  
  
  
  54. 　　{  
    55.   
  
  
  
  55. 　　Console.WriteLine("Interrupting the sleeping thread.");  
    56.   
  
  
  
  56. 　　sleeper.Interrupt();  
    57.   
  
  
  
  57. 　　}  
    58.   
  
  
  
  58. 　　}  
    59.   
  
  
  
  59. 　　}  
    60.   
  
  
  
  60. 　　}  
    61.   
  
  
  
  61. 　　} 
    62.

在上面的例子中，当计数器的值为10, 20 和 30 时第一个线程会睡眠。第二个线程会检查第一个线程是否已经进入睡眠状态。如果是的话，它将中断第一个线程并使它回到调度队列中去。Interrupt()方法是让睡眠线程重新醒来的最好方式，当线程等待的资源可用且你想让线程继续运行时你可以使用这个方法。输出结果与下面显示的类似：

网页题目：.NET中线程的生命周期
网站地址：http://www.csdahua.cn/qtweb/news30/499680.html

成都网站优化推广公司_创新互联，为您提供自适应网站、品牌网站制作、网站导航、网站策划、ChatGPT、网站内链

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站建设知识

同城分类信息

微商城开发　　 　服务器托管　　 　雪茄烟　　 　营销网站建设　　 　深圳纱窗安装　　 　网站制作　　 　成都微信公众号开发　　 　中国电信成都枢纽中心　　 　广告媒介投放　　 　H5建站　　 　服务器托管　　 　手机网站制作　　 　网站建设公司　　 　Google外贸推广　　 　ssl证书申请　　 　绵阳网站制作　　 　成都工装公司　　 　泸州叙永网站建设　　 　江油网站建设　　 　德阳服务器托管