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.mswzjz.cn/qtweb/news45/12545.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

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

贝锐智能技术为您推荐以下文章

网站导航知识

同城分类信息

西云服务器托管　　 　微信小程序开发　　 　绵阳服务器托管　　 　温江服务器租用　　 　娄底尾呼妄服装　　 　定制网站　　 　成都网络推广　　 　佑馨产后护理　　 　达州网站制作　　 　电信成都枢纽中心　　 　官网SEO排名　　 　德阳服务器托管　　 　买链接　　 　上市企业网站建设方案　　 　bgp多线机房托管　　 　雨棚定制　　 　成都小程序开发　　 　成都app开发　　 　网页设计制作　　 　成都网站建设公司