详解Winform多线程编程基本原理

本文在这里将从.NET并行计算讲起，主要环境为Winform多线程编程。希望通过本文能对大家了解Winform多线程编程有所帮助，用好.NET并行计算。向您推荐《WinForm应用与开发视频教程-WinForm教程》

创新互联公司网络公司拥有十年的成都网站开发建设经验，成百上千客户的共同信赖。提供成都网站建设、网站制作、网站开发、网站定制、买链接、建网站、网站搭建、响应式网站、网页设计师打造企业风格，提供周到的售前咨询和贴心的售后服务

首先我们创建一个Winform的应用程序，在上面添加一个多行文本框和一个按钮控件，按钮的事件如下：

 
 
 
 
    
  
  
  
  
  1. Thread.Sleep(1000);  
    2.   
  
  
  
  2. StringBuilder sb = new StringBuilder();  
    3.   
  
  
  
  3. for (int i = 0; i < 10000; i++)  
    4.   
  
  
  
  4.     sb.Append("test");  
    5.   
  
  
  
  5. string s = sb.ToString();  
    6.   
  
  
  
  6. textBox1.Text = s; 
    7.

首先我们可以把这个操作理解为一个非常耗时的操作，它至少占用1秒的时间。在1秒后，我们整了一个大字符串作为文本框的值，然后在标签上显示给文本框赋值这个UI渲染行为需要的时间，程序执行结果如下：

我们可以感受到，在点击了按钮之后整个程序的UI就卡住了，没有办法拖动没有办法改变大小，用于体验非常差。一般能想到会新建一个线程来包装这个方法，使得UI线程不被卡住：

 
 
 
 
    
  
  
  
  
  1. new Thread(() =>  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     Thread.Sleep(1000);  
    4.   
  
  
  
  4.     StringBuilder sb = new StringBuilder();  
    5.   
  
  
  
  5.     for (int i = 0; i < 10000; i++)  
    6.   
  
  
  
  6.         sb.Append("test");  
    7.   
  
  
  
  7.     string s = sb.ToString();  
    8.   
  
  
  
  8.     textBox1.Text = s;  
    9.   
  
  
  
  9. }).Start(); 
    10.

使用调试方式运行程序的话会得到如下的异常（非调试方式不会）：

虽然我们知道这样设置：

 
 
 
 
    
  
  
  
  
  1. Control.CheckForIllegalCrossThreadCalls = false; 
    2.

可以屏蔽这个错误，但是在非创建控件的线程去更新控件的状态的做法会导致很多问题，比如死锁和控件部分被更新等。微软推荐我们使用Control的Invoke或BeginInvoke方法来把涉及到控件状态更新的操作让UI线程去做：

 
 
 
 
    
  
  
  
  
  1. new Thread(() =>  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     Invoke(new Action(() =>  
    4.   
  
  
  
  4.     {  
    5.   
  
  
  
  5.         Thread.Sleep(1000);  
    6.   
  
  
  
  6.         StringBuilder sb = new StringBuilder();  
    7.   
  
  
  
  7.         for (int i = 0; i < 10000; i++)  
    8.   
  
  
  
  8.             sb.Append("test");  
    9.   
  
  
  
  9.         string s = sb.ToString();  
    10.   
  
  
  
  10.         textBox1.Text = s;  
    11.   
  
  
  
  11.     }));  
    12.   
  
  
  
  12. }).Start(); 
    13.

你可能会想到这么写，但是运行程序后可以发现界面依然是卡死。想一下，虽然我们新开了一个线程，但是马上又把整个代码段交给UI线程去做了，当然起不到效果。其实这个方法的工作可以分为两部分，一部分是我们数据的计算，一部分是把计算好的数据显示在界面上，我们只应该把真正和UI相关的操作放到Invoke中让UI线程去做：

 
 
 
 
    
  
  
  
  
  1. new Thread(() =>  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     Thread.Sleep(1000);  
    4.   
  
  
  
  4.     StringBuilder sb = new StringBuilder();  
    5.   
  
  
  
  5.     for (int i = 0; i < 10000; i++)  
    6.   
  
  
  
  6.         sb.Append("test");  
    7.   
  
  
  
  7.     string s = sb.ToString();  
    8.   
  
  
  
  8.     Invoke(new Action(() =>  
    9.   
  
  
  
  9.     {  
    10.   
  
  
  
  10.         textBox1.Text = s;  
    11.   
  
  
  
  11.     }));  
    12.   
  
  
  
  12. }).Start(); 
    13.

再测试一次可以发现，UI在前1秒多的时间没有卡死，在最后的一点时间还是卡死了。在继续研究卡死问题之前我们来看一下，Control提供了InvokeRequired属性来让我们判断当前线程是不是UI线程，或者说当前的操作是否需要进行Invoke：

 
 
 
 
    
  
  
  
  
  1. textBox1.Text = this.InvokeRequired.ToString();  
    2.   
  
  
  
  2. new Thread(() =>  
    3.   
  
  
  
  3. {  
    4.   
  
  
  
  4.     textBox1.Text += Environment.NewLine + this.InvokeRequired.ToString();  
    5.   
  
  
  
  5.     Invoke(new Action(() =>  
    6.   
  
  
  
  6.     {  
    7.   
  
  
  
  7.         textBox1.Text += Environment.NewLine + this.InvokeRequired.ToString();  
    8.   
  
  
  
  8.     }));  
    9.   
  
  
  
  9. }).Start();  
    10.

通过非调试方式启动程序可以得到如下结果：

很明显：

1） 在线程外的赋值不需要Invoke（在UI线程）

2） 在线程内的赋值需要Invoke（不在UI线程）

3） 在Invoke中的赋值已经封送给UI线程，所以不需要Invoke

继续研究卡死问题，您可能会想到，Control还提供了一个BeginInvoke方法，我们来试试看：

 
 
 
 
    
  
  
  
  
  1. new Thread(() =>  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     Thread.Sleep(1000);  
    4.   
  
  
  
  4.     StringBuilder sb = new StringBuilder();  
    5.   
  
  
  
  5.     for (int i = 0; i < 10000; i++)  
    6.   
  
  
  
  6.         sb.Append("test");  
    7.   
  
  
  
  7.     string s = sb.ToString();  
    8.   
  
  
  
  8.     BeginInvoke(new Action(() =>  
    9.   
  
  
  
  9.     {  
    10.   
  
  
  
  10.         textBox1.Text = s;  
    11.   
  
  
  
  11.     }));  
    12.   
  
  
  
  12. }).Start(); 
    13.

好像效果上还是没什么区别，那么Invoke和BeginInvoke的区别在哪里呢？

我们知道Windows应用程序基于消息，Windows API提供了SendMessage和PostMessage两个API，前者执行消息后返回（不经过消息管道，先于PostMessage执行），后者把消息发送到管道异步执行。Invoke和BeginInvoke从行为上来说类似这两个API，但是实际上两者都使用了PostMessage，前者使用信号量在消息执行前阻塞，达到同步的效果。我们来做一个实验：

 
 
 
 
    
  
  
  
  
  1. new Thread(() =>  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     Thread.Sleep(1000);  
    4.   
  
  
  
  4.     StringBuilder sb = new StringBuilder();  
    5.   
  
  
  
  5.     for (int i = 0; i < 10000; i++)  
    6.   
  
  
  
  6.         sb.Append("test");  
    7.   
  
  
  
  7.     string s = sb.ToString();  
    8.   
  
  
  
  8.     Stopwatch sw = Stopwatch.StartNew();  
    9.   
  
  
  
  9.     Invoke(new Action(() =>  
    10.   
  
  
  
  10.     {  
    11.   
  
  
  
  11.         textBox1.Text = s;  
    12.   
  
  
  
  12.     }));  
    13.   
  
  
  
  13.     MessageBox.Show(sw.ElapsedMilliseconds.ToString());  
    14.   
  
  
  
  14. }).Start(); 
    15.

运行程序：

可以体会到，在文本框的值出现之后才出现弹出框，文本框赋值这个消息的执行过程耗时2秒。把Invoke改为BeginInvoke其它不动再执行程序：

明显感到弹出框先显示2秒后文本框的值出现。BeginInvoke没有阻塞后续语句的执行。因此，需要注意，如果我们在方法中使用的变量在BeginInvoke之后有修改，极有可能发生混乱。如果您使用过委托的BeginInvoke应该会知道，通常建议总是调用EndInvoke来回收资源，对于Control的EndInvoke来说，如果您不需要获取返回值的话，那么它不是必须的（来自msdn）。

#T#

现在您可能还有疑问为什么使用了BeginInvoke，UI还是卡了大概2秒，可以这么理解，我们把这么多的文字赋值到文本框中，这个UI行为是非常耗时的，不管是Invoke还是BeginInvoke最终是发送消息给UI线程处理（两者都没有使用线程池），它就是需要这么多时间，在一般情况下我们不会在UI上呈现这么多数据。

一般来说我们能做的优化是：

1） 尽量把非UI的操作使用新的线程去异步计算，不阻塞UI线程，真正需要操作UI的时候才去提交给UI线程

2） 尽量减少UI的操作复杂度，比如如果需要在UI上绘制一个复杂图形可以在内存中先创建一个位图，绘制好之后把整个位图在UI上绘制，而不是直接在UI上绘制这个图形

举个例子，UI就好象一块画布，我们要在上面画一个巨作怎么才能不过多占用这块布的时间，让大家都能用上呢？一个方法就是我们在准备颜色和画笔的时候不占着这个布，真正要去画的时候才去用，另外一个方法就是在另一块画布上先画，然后把图案采用复印的方式印到我们的主画布上。

对于大量数据的呈现，我们还可以：

1） 采用分页，只显示一部分数据，对于Windows程序的分页可能就是滚动条性质的了，在滚动条下拉的时候再去呈现当前“页”的数据

2） 即使是一页的数据，也可以一部分一部分呈现

举个例子，对于word文档的加载一般我们一打开就可以看到第一页，然后滚动块慢慢变小，页数慢慢增多，如果一开始就加载1000页的话我们可能要1分钟后才能看到第一页，如果等不及直接向后翻滚动条的话会立即加载后面的数据：

 
 
 
 
    
  
  
  
  
  1. new Thread(() =>  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.     StringBuilder sb = new StringBuilder();  
    4.   
  
  
  
  4.     for (int i = 0; i < 100; i++)  
    5.   
  
  
  
  5.         sb.Append("test");  
    6.   
  
  
  
  6.     string s = sb.ToString();  
    7.   
  
  
  
  7.     for (int i = 0; i < 20; i++)  
    8.   
  
  
  
  8.     {  
    9.   
  
  
  
  9.         BeginInvoke(new Action(() =>  
    10.   
  
  
  
  10.         {  
    11.   
  
  
  
  11.             textBox1.Text += s + i;  
    12.   
  
  
  
  12.         }));  
    13.   
  
  
  
  13.         Thread.Sleep(10);  
    14.   
  
  
  
  14.     }  
    15.   
  
  
  
  15. }).Start(); 
    16.

设置文本框允许纵向滚动条并且运行一下这段程序可以体会到这个效果：

新闻标题：详解Winform多线程编程基本原理
URL网址：http://www.shufengxianlan.com/qtweb/news33/498733.html

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

广告

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

猜你还喜欢下面的内容

电子商务知识

分类信息网

复盛机电设备安装　　 　成都包装盒设计　　 　成都免费网站建设公司　　 　成都搬家公司　　 　泸州网站建设　　 　小谭建站　　 　贵州义龙电信机房　　 　小谭网创广告　　 　企业微信定制　　 　服务器托管　　 　达州博佩科技　　 　广汉锦华　　 　成都网络推广　　 　成都网络营销　　 　成都网站建设　　 　巴彦网站建设　　 　马边网站建设　　 　凯亚自动化控制　　 　无边发光字　　 　品牌设计