日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
C#線程的啟動

在實例化Thread的實例，需要提供一個委托，在實例化這個委托時所用到的參數(shù)是線程將來啟動時要運行的方法。在.net中提供了兩種啟動線程的方式，一種是不帶參數(shù)的啟動方式，另一種是帶參數(shù)的啟動的方式。

在實例化Thread的實例，需要提供一個委托，在實例化這個委托時所用到的參數(shù)是線程將來啟動時要運行的方法。在.net中提供了兩種啟動線程的方式，一種是不帶參數(shù)的啟動方式，另一種是帶參數(shù)的啟動的方式。

C#線程的啟動：不帶參數(shù)的啟動方式

如果啟動參數(shù)時無需其它額外的信息，可以使用ThreadStart來實例化Thread，如下面的代碼：

 
 
 
    
  
  
  
  1. 　    using System;   
    2.   
  
  
  2. 　　 using System.Collections.Generic;   
    3.   
  
  
  3. 　　 using System.Text;   
    4.   
  
  
  4. 　　 using System.Threading;   
    5.   
  
  
  5. 　　   
    6.   
  
  
  6. 　　 namespace StartThread   
    7.   
  
  
  7. 　　 {   
    8.   
  
  
  8. 　　 class Program   
    9.   
  
  
  9. 　　 {   
    10.   
  
  
  10. 　　 int interval = 200;   
    11.   
  
  
  11. 　　 static void Main(string[] args)   
    12.   
  
  
  12. 　　 {   
    13.   
  
  
  13. 　　 Program p = new Program();   
    14.   
  
  
  14. 　　 Thread nonParameterThread = new Thread(new ThreadStart(p.NonParameterRun));   
    15.   
  
  
  15. 　　 nonParameterThread.Start();   
    16.   
  
  
  16. 　　 }   
    17.   
  
  
  17. 　　 ///    
    18.   
  
  
  18. 　　 /// 不帶參數(shù)的啟動方法   
    19.   
  
  
  19. 　　 ///    
    20.   
  
  
  20. 　　 public void NonParameterRun()   
    21.   
  
  
  21. 　　 {   
    22.   
  
  
  22. 　　 for (int i = 0; i <   10; i++)   
    23.   
  
  
  23. 　　 {   
    24.   
  
  
  24. 　　 Console.WriteLine("系統(tǒng)當前時間毫秒值："+DateTime.Now.Millisecond.ToString());   
    25.   
  
  
  25. 　　 Thread.Sleep(interval);//讓線程暫停   
    26.   
  
  
  26. 　　 }   
    27.   
  
  
  27. 　　 }   
    28.   
  
  
  28. 　　 }  
    29.

程序的運行效果我們不用運行也會知道，那就是在循環(huán)中將系統(tǒng)當前時間的毫秒部分輸出出來，在每次輸出之后會將當前線程暫停一下，直到10次之后運行完畢，終止線程的執(zhí)行。

在上面的代碼中我們是通過定義全局變量的方法來指定線程暫停間隔，按照這種方法，假如要運行10個線程，每個線程的暫停間隔不一樣的話，就需要定義10個全局變量，雖然最終不影響系統(tǒng)的運行效果，但是總覺得不是太爽。

有沒有比較簡單一點的辦法呢?有!那就是使用帶參數(shù)的啟動方法。

C#線程的啟動：帶參數(shù)的啟動方法

如果要在實例化線程時要帶一些參數(shù)，就不能用ThreadStart委托作為構造函數(shù)的參數(shù)來實例化Thread了，而要ParameterizedThreadStart委托，和ThreadStart一樣的是它也是線程啟動時要執(zhí)行的方法，和ThreadStart不同的是，它在實例化時可以用一個帶有一個Object參數(shù)的方法作為構造函數(shù)的參數(shù)，而實例化ThreadStart時所用到的方法是沒有參數(shù)的。

為什么是Object這樣的參數(shù)呢?很簡單，因為在.net中Object是所有類型的基類，用它可以表示Array(數(shù)組)、Interface(接口)、ValueType(值類型，如bool,byte,char,short,int,float,long,double等)、class(類)等.net中的類型。當然，這也意味著如果你要啟動一個線程，給它傳遞一個int類型參數(shù)時，必須在啟動方法中進行相應的類型轉(zhuǎn)換。

下面就是一個例子，在啟動線程時指定了線程的暫停間隔，代碼如下：

          

 
 
 
    
  
  
  
  1. using System;   
    2.   
  
  
  2. 　　 using System.Collections.Generic;   
    3.   
  
  
  3. 　　 using System.Text;   
    4.   
  
  
  4. 　　 using System.Threading;   
    5.   
  
  
  5. 　　   
    6.   
  
  
  6. 　　 namespace StartThread   
    7.   
  
  
  7. 　　 {   
    8.   
  
  
  8. 　　 class Program   
    9.   
  
  
  9. 　　 {   
    10.   
  
  
  10. 　　 int interval = 200;   
    11.   
  
  
  11. 　　 static void Main(string[] args)   
    12.   
  
  
  12. 　　 {   
    13.   
  
  
  13. 　　 Program p = new Program();   
    14.   
  
  
  14. 　　   
    15.   
  
  
  15. 　　 Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));   
    16.   
  
  
  16. 　　 parameterThread.Name = "Thread A:";   
    17.   
  
  
  17. 　　 parameterThread.Start(30);   
    18.   
  
  
  18. 　　 }   
    19.   
  
  
  19. 　　   
    20.   
  
  
  20. 　　 ///    
    21.   
  
  
  21. 　　 /// 帶參數(shù)的啟動方法   
    22.   
  
  
  22. 　　 ///    
    23.   
  
  
  23. 　　 /// 讓線程在運行過程中的休眠間隔   
    24.   
  
  
  24. 　　 public void ParameterRun(object ms)   
    25.   
  
  
  25. 　　 {   
    26.   
  
  
  26. 　　 int j = 10;   
    27.   
  
  
  27. 　　 int.TryParse(ms.ToString(), out j);//這里采用了TryParse方法，避免不能轉(zhuǎn)換時出現(xiàn)異常   
    28.   
  
  
  28. 　　 for (int i = 0; i <   10; i++)   
    29.   
  
  
  29. 　　 {   
    30.   
  
  
  30. 　　 Console.WriteLine(Thread.CurrentThread.Name+"系統(tǒng)當前時間毫秒值：" + DateTime.Now.Millisecond.ToString());   
    31.   
  
  
  31. 　　 Thread.Sleep(j);//讓線程暫停   
    32.   
  
  
  32. 　　 }   
    33.   
  
  
  33. 　　 }   
    34.   
  
  
  34. 　　 }   
    35.   
  
  
  35. 　　 }  
    36.

在這個方法里，我們在啟動線程時順便指定了線程的暫停間隔，也就是這句：

 
 
 
    
  
  
  
  1. parameterThread.Start(30);  
    2.

線程啟動時運行的方法是public void ParameterRun(object ms)，這個值為30的int類型變量被裝箱成object，所以在方法中還需要將它轉(zhuǎn)換成int類型，這個可以通過拆箱或者其它辦法解決。

假如我們要啟動兩個線程，每個線程的暫停間隔不一樣，啟動代碼如下：　     

 
 
 
    
  
  
  
  1.  using System;   
    2.   
  
  
  2. 　　 using System.Collections.Generic;   
    3.   
  
  
  3. 　　 using System.Text;   
    4.   
  
  
  4. 　　 using System.Threading;   
    5.   
  
  
  5. 　　   
    6.   
  
  
  6. 　　 namespace StartThread   
    7.   
  
  
  7. 　　 {   
    8.   
  
  
  8. 　　 class Program   
    9.   
  
  
  9. 　　 {   
    10.   
  
  
  10. 　　 int interval = 200;   
    11.   
  
  
  11. 　　 static void Main(string[] args)   
    12.   
  
  
  12. 　　 {   
    13.   
  
  
  13. 　　 Program p = new Program();   
    14.   
  
  
  14. 　　   
    15.   
  
  
  15. 　　 Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));   
    16.   
  
  
  16. 　　 parameterThread.Name = "Thread A:";   
    17.   
  
  
  17. 　　 parameterThread.Start(30);   
    18.   
  
  
  18. 　　 //啟動第二個線程   
    19.   
  
  
  19. 　　 parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));   
    20.   
  
  
  20. 　　 parameterThread.Name = "Thread B:";   
    21.   
  
  
  21. 　　 parameterThread.Start(60);   
    22.   
  
  
  22. 　　 }   
    23.   
  
  
  23. 　　   
    24.   
  
  
  24. 　　 ///    
    25.   
  
  
  25. 　　 /// 帶參數(shù)的啟動方法   
    26.   
  
  
  26. 　　 ///    
    27.   
  
  
  27. 　　 /// 讓線程在運行過程中的休眠間隔   
    28.   
  
  
  28. 　　 public void ParameterRun(object ms)   
    29.   
  
  
  29. 　　 {   
    30.   
  
  
  30. 　　 int j = 10;   
    31.   
  
  
  31. 　　 int.TryParse(ms.ToString(), out j);//這里采用了TryParse方法，避免不能轉(zhuǎn)換時出現(xiàn)異常   
    32.   
  
  
  32. 　　 for (int i = 0; i <   10; i++)   
    33.   
  
  
  33. 　　 {   
    34.   
  
  
  34. 　　 Console.WriteLine(Thread.CurrentThread.Name+"系統(tǒng)當前時間毫秒值：" + DateTime.Now.Millisecond.ToString());   
    35.   
  
  
  35. 　　 Thread.Sleep(j);//讓線程暫停   
    36.   
  
  
  36. 　　 }   
    37.   
  
  
  37. 　　 }   
    38.   
  
  
  38. 　　 }   
    39.   
  
  
  39. 　　 }  
    40.

對上面的代碼做一點說明，就是線程啟動之后，線程的實例不必再存在，例如在上面的代碼中我用的是同一個實例實例化了兩個線程，并且這兩個線程運行很正常。

C#線程的啟動：繼續(xù)探索

上面解決了一個問題，如果在啟動線程時需要參數(shù)如何解決，如果針對上面的問題繼續(xù)發(fā)掘，比如：在啟動線程時不但要指定線程的暫停間隔，還需要指定循環(huán)次數(shù)(在上面的所有例子中都是執(zhí)行10次的)，這個問題該如何解決呢?

有兩種辦法可以解決：

首先可以繼續(xù)在ParameterizedThreadStart這里做文章，因為這里可以使用一個Object類型的參數(shù)，那么可以通過數(shù)組或者一個類來解決(因為它們都是Object的子類)。我在做某個系統(tǒng)時確實采用數(shù)組處理過這種情況，這樣就要求在線程啟動方法中必須清楚知道數(shù)組中每個參數(shù)的用途，不是太方便。

這里說說重新定義一個實體類來解決的方法，代碼如下。  

 
 
 
    
  
  
  
  1.    　using System;   
    2.   
  
  
  2. 　　 using System.Collections.Generic;   
    3.   
  
  
  3. 　　 using System.Text;   
    4.   
  
  
  4. 　　 using System.Threading;   
    5.   
  
  
  5. 　　   
    6.   
  
  
  6. 　　 namespace StartThread   
    7.   
  
  
  7. 　　 {   
    8.   
  
  
  8. 　　 class MyThreadParameter   
    9.   
  
  
  9. 　　 {   
    10.   
  
  
  10. 　　 private int interval;   
    11.   
  
  
  11. 　　 private int loopCount;   
    12.   
  
  
  12. 　　 ///    
    13.   
  
  
  13. 　　 /// 循環(huán)次數(shù)   
    14.   
  
  
  14. 　　 ///    
    15.   
  
  
  15. 　　 public int LoopCount   
    16.   
  
  
  16. 　　 {   
    17.   
  
  
  17. 　　 get { return loopCount; }   
    18.   
  
  
  18. 　　 }   
    19.   
  
  
  19. 　　   
    20.   
  
  
  20. 　　 ///    
    21.   
  
  
  21. 　　 /// 線程的暫停間隔   
    22.   
  
  
  22. 　　 ///    
    23.   
  
  
  23. 　　 public int Interval   
    24.   
  
  
  24. 　　 {   
    25.   
  
  
  25. 　　 get { return interval; }   
    26.   
  
  
  26. 　　 }   
    27.   
  
  
  27. 　　 ///    
    28.   
  
  
  28. 　　 /// 構造函數(shù)   
    29.   
  
  
  29. 　　 ///    
    30.   
  
  
  30. 　　 /// 線程的暫停間隔   
    31.   
  
  
  31. 　　 /// 循環(huán)次數(shù)   
    32.   
  
  
  32. 　　 public MyThreadParameter(int interval,int loopCount)   
    33.   
  
  
  33. 　　 {   
    34.   
  
  
  34. 　　 this.interval = interval;   
    35.   
  
  
  35. 　　 this.loopCount = loopCount;   
    36.   
  
  
  36. 　　 }   
    37.   
  
  
  37. 　　 }   
    38.   
  
  
  38. 　　 class Program   
    39.   
  
  
  39. 　　 {   
    40.   
  
  
  40. 　　 int interval = 200;   
    41.   
  
  
  41. 　　 static void Main(string[] args)   
    42.   
  
  
  42. 　　 {   
    43.   
  
  
  43. 　　 Program p = new Program();   
    44.   
  
  
  44. 　　   
    45.   
  
  
  45. 　　 Thread parameterThread = new Thread(new ParameterizedThreadStart(p.MyParameterRun));   
    46.   
  
  
  46. 　　 parameterThread.Name = "Thread A:";   
    47.   
  
  
  47. 　　 MyThreadParameter paramter = new MyThreadParameter(50, 20);   
    48.   
  
  
  48. 　　 parameterThread.Start(paramter);   
    49.   
  
  
  49. 　　 }   
    50.   
  
  
  50. 　　   
    51.   
  
  
  51. 　　   
    52.   
  
  
  52. 　　 ///    
    53.   
  
  
  53. 　　 /// 帶多個參數(shù)的啟動方法   
    54.   
  
  
  54. 　　 ///    
    55.   
  
  
  55. 　　 /// 方法參數(shù)   
    56.   
  
  
  56. 　　 public void MyParameterRun(object ms)   
    57.   
  
  
  57. 　　 {   
    58.   
  
  
  58. 　　 MyThreadParameter parameter = ms as MyThreadParameter;//類型轉(zhuǎn)換   
    59.   
  
  
  59. 　　 if (parameter != null)   
    60.   
  
  
  60. 　　 {   
    61.   
  
  
  61. 　　 for (int i = 0; i <   parameter.LoopCount; i++)   
    62.   
  
  
  62. 　　 {   
    63.   
  
  
  63. 　　 Console.WriteLine(Thread.CurrentThread.Name + "系統(tǒng)當前時間毫秒值：" + DateTime.Now.Millisecond.ToString());   
    64.   
  
  
  64. 　　 Thread.Sleep(parameter.Interval);//讓線程暫停   
    65.   
  
  
  65. 　　 }   
    66.   
  
  
  66. 　　 }   
    67.   
  
  
  67. 　　 }   
    68.   
  
  
  68. 　　 }   
    69.   
  
  
  69. 　　 }  
    70.

第二種方法和上面方法有些相似，也是需要引入外部類，并且將Thread實例放在引入的類中，這種情況適合于在線程中處理的業(yè)務邏輯比較復雜的情況。在前不久處理的一個項目中我用過這種情況，它是用來實現(xiàn)雙向數(shù)據(jù)傳輸?shù)摹?/p>

如果實現(xiàn)上面的效果，代碼如下：

 
 
 
    
  
  
  
  1.      　using System;   
    2.   
  
  
  2. 　　 using System.Collections.Generic;   
    3.   
  
  
  3. 　　 using System.Text;   
    4.   
  
  
  4. 　　 using System.Threading;   
    5.   
  
  
  5. 　　   
    6.   
  
  
  6. 　　 namespace StartThread   
    7.   
  
  
  7. 　　 {   
    8.   
  
  
  8. 　　 class MyThreadParameter   
    9.   
  
  
  9. 　　 {   
    10.   
  
  
  10. 　　 private int interval;   
    11.   
  
  
  11. 　　 private int loopCount;   
    12.   
  
  
  12. 　　 private Thread thread;   
    13.   
  
  
  13. 　　   
    14.   
  
  
  14. 　　 ///    
    15.   
  
  
  15. 　　 /// 構造函數(shù)   
    16.   
  
  
  16. 　　 ///    
    17.   
  
  
  17. 　　 /// 線程的暫停間隔   
    18.   
  
  
  18. 　　 /// 循環(huán)次數(shù)   
    19.   
  
  
  19. 　　 public MyThreadParameter(int interval,int loopCount)   
    20.   
  
  
  20. 　　 {   
    21.   
  
  
  21. 　　 this.interval = interval;   
    22.   
  
  
  22. 　　 this.loopCount = loopCount;   
    23.   
  
  
  23. 　　 thread = new Thread(new ThreadStart(Run));   
    24.   
  
  
  24. 　　 }   
    25.   
  
  
  25. 　　   
    26.   
  
  
  26. 　　 public void Start()   
    27.   
  
  
  27. 　　 {   
    28.   
  
  
  28. 　　 if (thread != null)   
    29.   
  
  
  29. 　　 {   
    30.   
  
  
  30. 　　 thread.Start();   
    31.   
  
  
  31. 　　 }   
    32.   
  
  
  32. 　　 }   
    33.   
  
  
  33. 　　   
    34.   
  
  
  34. 　　 private void Run()   
    35.   
  
  
  35. 　　 {   
    36.   
  
  
  36. 　　 for (int i = 0; i <   loopCount; i++)   
    37.   
  
  
  37. 　　 {   
    38.   
  
  
  38. 　　 Console.WriteLine("系統(tǒng)當前時間毫秒值：" + DateTime.Now.Millisecond.ToString());   
    39.   
  
  
  39. 　　 Thread.Sleep(interval);//讓線程暫停   
    40.   
  
  
  40. 　　 }   
    41.   
  
  
  41. 　　 }   
    42.   
  
  
  42. 　　 }   
    43.   
  
  
  43. 　　 class Program   
    44.   
  
  
  44. 　　 {   
    45.   
  
  
  45. 　　 static void Main(string[] args)   
    46.   
  
  
  46. 　　 {   
    47.   
  
  
  47. 　　 MyThreadParameter parameterThread = new MyThreadParameter(30, 50);   
    48.   
  
  
  48. 　　 parameterThread.Start();   
    49.   
  
  
  49. 　　 }   
    50.   
  
  
  50. 　　   
    51.   
  
  
  51. 　　 }   
    52.   
  
  
  52. 　　 }  
    53.

上面的代碼的運行效果和前面的代碼運行效果類似，只不過是將業(yè)務處理代碼放在一個單獨的類MyThreadParameter中，使得MyThreadParameter看起來也像一個Thread，實際上維護的還是其內(nèi)部的Thread，在一些大型系統(tǒng)中這樣做的好處是便于維護。

總結(jié)：在本篇主要講述如何啟動C#線程的問題，在啟動時可能會遇到無需參數(shù)、需要多個參數(shù)的情況，在這里講述了如何解決這些問題的思路。在.net類庫中雖然存在著龐大的類庫，但是并不是總會有合適的類來解決我們所遇到的問題，但是只要肯動腦筋總會想到合適的辦法。


網(wǎng)站名稱：C#線程的啟動
文章源于：http://m.5511xx.com/article/djhipgh.html