Winform中C#线程控制的四种常见情况分析

Winform界面中，将事务放在新开的线程中操作是十分有用的做法，因为这样可以增加用户体验，减少耗时。对这些C#线程的控制，常常有下面这四种情况：

成都创新互联公司服务项目包括秦淮网站建设、秦淮网站制作、秦淮网页制作以及秦淮网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，秦淮网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到秦淮省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

1. 启动线程；

2. 线程间通讯；

3. 线程终止；

4. 线程中的异常处理；

下面总结一些上面这些C#线程操作的常用方法。

C#线程控制1. 启动C#线程

◆如果是需要很频繁的开线程，会使用线程池（微软的或自己写的）

◆Thread.Start(参数object);

◆或者用对象提供的BeginXXXX()这种都是异步,也算多线程启动.

C#线程控制2. C#线程间通讯

◆委托,事件这些比较常用,并且对object的多线程处理需要谨慎,可能用到lock(object){}.

◆主要是通过线程同步或者回调方法（或者说是委托）来实现

C#线程控制3. 线程终止

◆线程的终止，用事件AUTORESET之类

◆可以用Thread.ManualEvent().Reset()/Set()/WaitOne()方法来判断和等待

C#线程控制4. 线程中的异常处理

◆线程中的异常通过事件传回到主线程处理

◆还是写log吧,多线程debug比较难,还是逐步log比较好.

用于C#线程通讯的lock关键字

下面的示例演示使用 lock 关键字以及 AutoResetEvent 和 ManualResetEvent 类对主线程和两个辅助线程进行线程同步。

该示例创建两个辅助线程。一个线程生成元素并将它们存储在非线程安全的泛型队列中。有关更多信息，请参见 Queue。另一个线程使用此队列中的项。另外，主线程定期显示队列的内容，因此该队列被三个线程访问。lock 关键字用于同步对队列的访问，以确保队列的状态没有被破坏。

除了用 lock 关键字来阻止同时访问外，还用两个事件对象提供进一步的同步。一个事件对象用来通知辅助线程终止，另一个事件对象由制造者线程用来在有新项添加到队列中时通知使用者线程。这两个事件对象封装在一个名为 SyncEvents 的类中。这使事件可以轻松传递到表示制造者线程和使用者线程的对象。SyncEvents 类是按如下方式定义的：

C# code

 
 
 
    
  
  
  
  1. using System;  
    2. 
  
  
  
  2. using System.Threading;  
    3. 
  
  
  
  3. using System.Collections;  
    4. 
  
  
  
  4. using System.Collections.Generic;  
    5. 
  
  
  
  5. 
  
  
  
  6. public class SyncEvents  
    7. 
  
  
  
  7. {  
    8. 
  
  
  
  8. public SyncEvents()  
    9. 
  
  
  
  9. {  
    10. 
  
  
  
  10. 
  
  
  
  11. _newItemEvent = new AutoResetEvent(false);  
    12. 
  
  
  
  12. _exitThreadEvent = new ManualResetEvent(false);  
    13. 
  
  
  
  13. _eventArray = new WaitHandle[2];  
    14. 
  
  
  
  14. _eventArray[0] = _newItemEvent;  
    15. 
  
  
  
  15. _eventArray[1] = _exitThreadEvent;  
    16. 
  
  
  
  16. }  
    17. 
  
  
  
  17. 
  
  
  
  18. public EventWaitHandle ExitThreadEvent  
    19. 
  
  
  
  19. {  
    20. 
  
  
  
  20. get { return _exitThreadEvent; }  
    21. 
  
  
  
  21. }  
    22. 
  
  
  
  22. public EventWaitHandle NewItemEvent  
    23. 
  
  
  
  23. {  
    24. 
  
  
  
  24. get { return _newItemEvent; }  
    25. 
  
  
  
  25. }  
    26. 
  
  
  
  26. public WaitHandle[] EventArray  
    27. 
  
  
  
  27. {  
    28. 
  
  
  
  28. get { return _eventArray; }  
    29. 
  
  
  
  29. }  
    30. 
  
  
  
  30. 
  
  
  
  31. private EventWaitHandle _newItemEvent;  
    32. 
  
  
  
  32. private EventWaitHandle _exitThreadEvent;  
    33. 
  
  
  
  33. private WaitHandle[] _eventArray;  
    34. 
  
  
  
  34. }  
    35. 
  
  
  
  35. public class Producer  
    36. 
  
  
  
  36. {  
    37. 
  
  
  
  37. public Producer(Queue  q, SyncEvents e)  
    38. 
  
  
  
  38. {  
    39. 
  
  
  
  39. _queue = q;  
    40. 
  
  
  
  40. _syncEvents = e;  
    41. 
  
  
  
  41. }  
    42. 
  
  
  
  42. // Producer.ThreadRun  
    43. 
  
  
  
  43. public void ThreadRun()  
    44. 
  
  
  
  44. {  
    45. 
  
  
  
  45. int count = 0;  
    46. 
  
  
  
  46. Random r = new Random();  
    47. 
  
  
  
  47. while (!_syncEvents.ExitThreadEvent.WaitOne(0, false))  
    48. 
  
  
  
  48. {  
    49. 
  
  
  
  49. lock (((ICollection)_queue).SyncRoot)  
    50. 
  
  
  
  50. {  
    51. 
  
  
  
  51. while (_queue.Count < 20)  
    52. 
  
  
  
  52. {  
    53. 
  
  
  
  53. _queue.Enqueue(r.Next(0,100));  
    54. 
  
  
  
  54. _syncEvents.NewItemEvent.Set();  
    55. 
  
  
  
  55. count++;  
    56. 
  
  
  
  56. }  
    57. 
  
  
  
  57. }  
    58. 
  
  
  
  58. }  
    59. 
  
  
  
  59. Console.WriteLine("Producer thread: produced {0} items", count);  
    60. 
  
  
  
  60. }  
    61. 
  
  
  
  61. private Queue  _queue;  
    62. 
  
  
  
  62. private SyncEvents _syncEvents;  
    63. 
  
  
  
  63. }  
    64. 
  
  
  
  64. 
  
  
  
  65. public class Consumer  
    66. 
  
  
  
  66. {  
    67. 
  
  
  
  67. public Consumer(Queue  q, SyncEvents e)  
    68. 
  
  
  
  68. {  
    69. 
  
  
  
  69. _queue = q;  
    70. 
  
  
  
  70. _syncEvents = e;  
    71. 
  
  
  
  71. }  
    72. 
  
  
  
  72. // Consumer.ThreadRun  
    73. 
  
  
  
  73. public void ThreadRun()  
    74. 
  
  
  
  74. {  
    75. 
  
  
  
  75. int count = 0;  
    76. 
  
  
  
  76. while (WaitHandle.WaitAny(_syncEvents.EventArray) != 1)  
    77. 
  
  
  
  77. {  
    78. 
  
  
  
  78. lock (((ICollection)_queue).SyncRoot)  
    79. 
  
  
  
  79. {  
    80. 
  
  
  
  80. int item = _queue.Dequeue();  
    81. 
  
  
  
  81. }  
    82. 
  
  
  
  82. count++;  
    83. 
  
  
  
  83. }  
    84. 
  
  
  
  84. Console.WriteLine("Consumer Thread: consumed {0} items", count);  
    85. 
  
  
  
  85. }  
    86. 
  
  
  
  86. private Queue  _queue;  
    87. 
  
  
  
  87. private SyncEvents _syncEvents;  
    88. 
  
  
  
  88. }  
    89. 
  
  
  
  89. 
  
  
  
  90. public class ThreadSyncSample  
    91. 
  
  
  
  91. {  
    92. 
  
  
  
  92. private static void ShowQueueContents(Queue  q)  
    93. 
  
  
  
  93. {  
    94. 
  
  
  
  94. lock (((ICollection)q).SyncRoot)  
    95. 
  
  
  
  95. {  
    96. 
  
  
  
  96. foreach (int item in q)  
    97. 
  
  
  
  97. {  
    98. 
  
  
  
  98. Console.Write("{0} ", item);  
    99. 
  
  
  
  99. }  
    100. 
  
  
  
  100. }  
    101. 
  
  
  
  101. Console.WriteLine();  
    102. 
  
  
  
  102. }  
    103. 
  
  
  
  103. 
  
  
  
  104. static void Main()  
    105. 
  
  
  
  105. {  
    106. 
  
  
  
  106. Queue  queue = new Queue ();  
    107. 
  
  
  
  107. SyncEvents syncEvents = new SyncEvents();  
    108. 
  
  
  
  108. 
  
  
  
  109. Console.WriteLine("Configuring worker threads...");  
    110. 
  
  
  
  110. Producer producer = new Producer(queue, syncEvents);  
    111. 
  
  
  
  111. Consumer consumer = new Consumer(queue, syncEvents);  
    112. 
  
  
  
  112. Thread producerThread = new Thread(producer.ThreadRun);  
    113. 
  
  
  
  113. Thread consumerThread = new Thread(consumer.ThreadRun);  
    114. 
  
  
  
  114. 
  
  
  
  115. Console.WriteLine("Launching producer and consumer threads..."); 
    116. 
  
  
  
  116. producerThread.Start();  
    117. 
  
  
  
  117. consumerThread.Start();  
    118. 
  
  
  
  118. 
  
  
  
  119. for (int i=0; i <4; i++)  
    120. 
  
  
  
  120. {  
    121. 
  
  
  
  121. Thread.Sleep(2500);  
    122. 
  
  
  
  122. ShowQueueContents(queue);  
    123. 
  
  
  
  123. }  
    124. 
  
  
  
  124. 
  
  
  
  125. Console.WriteLine("Signaling threads to terminate...");  
    126. 
  
  
  
  126. syncEvents.ExitThreadEvent.Set();  
    127. 
  
  
  
  127. 
  
  
  
  128. producerThread.Join();  
    129. 
  
  
  
  129. consumerThread.Join();  
    130. 
  
  
  
  130. }  
    131. 
  
  
  
  131. 
  
  
  
  132. } 
    133. 
  
  
  
  133.

本文题目：Winform中C#线程控制的四种常见情况分析
本文来源：http://www.hantingmc.com/qtweb/news45/12545.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

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

猜你还喜欢下面的内容

App设计知识

分类信息网站

鸿程源茂　　 　成都网站SEO优化公司　　 　成都广告制作　　 　眉山联通机房　　 　成都网站制作　　 　八点广告　　 　温江电信机房　　 　成都二枢机房　　 　广汉锦华　　 　高县网站建设　　 　达州网站建设　　 　租用服务器　　 　成都酒店服定制　　 　网络营销推广　　 　渠县网站建设　　 　广安园林绿化公司　　 　广安做网站　　 　域名注册　　 　德阳服务器托管　　 　成都做网站建设公司