一个例子形象的理解协程和线程的区别

一个例子形象的理解协程和线程的区别

Talk is cheap, show me the code! 所以，废话先不说，先上代码：
首先写一个WebAPI接口

1. /// <summary>
2. /// 测试接口
3. /// </summary>
4. [RoutePrefix("api/test")]
5. public class TestController : ApiController
6. {
7.     /// <summary>
8.     /// 测试GET请求
9.     /// </summary>
10.     /// <param name="val">测试参数</param>
11.     [HttpGet]
12.     [Route("TestGet")]
13.     public HttpResponseMessage TestGet(string val)
14.     {
15.         Thread.Sleep(200); //模拟执行耗时操作
17.         return new HttpResponseMessage { Content = new StringContent(val.ToString(), Encoding.UTF8, "text/plain") };
18.     }
19. }

复制代码

测试代码

1. using System;
2. using System.Collections.Generic;
3. using System.Diagnostics;
4. using System.Linq;
5. using System.Text;
6. using System.Threading;
7. using System.Threading.Tasks;
8. using System.Windows.Forms;
9. using Utils;
11. namespace AsyncDemo2
12. {
13.     public partial class Form1 : Form
14.     {
15.         private int n = 200;
17.         public Form1()
18.         {
19.             InitializeComponent();
21.             Task.Factory.StartNew(() =>
22.             {
23.                 while (true)
24.                 {
25.                     Thread.Sleep(100);
27.                     ThreadPool.GetMaxThreads(out int w1, out int c1);
28.                     ThreadPool.GetAvailableThreads(out int w2, out int c2);
30.                     int w = w1 - w2;
31.                     int c = c1 - c2;
32.                     label1.BeginInvoke(new Action(() =>
33.                     {
34.                         label1.Text = string.Format("工作线程：{0} 异步线程：{1}", w, c);
35.                     }));
36.                 }
37.             }, TaskCreationOptions.LongRunning);
38.         }
40.         /// <summary>
41.         /// 日志输出
42.         /// </summary>
43.         private void Log(string msg)
44.         {
45.             this.BeginInvoke(new Action(() =>
46.             {
47.                 textBox1.AppendText(DateTime.Now.ToString("mm:ss.fff") + "：" + msg + "\r\n");
48.             }));
49.         }
51.         /// <summary>
52.         /// 异步请求
53.         /// </summary>
54.         private async Task ReqeustAsync(int val)
55.         {
56.             try
57.             {
58.                 Log("异步  开始请求" + val);
59.                 string result = await HttpUtil.HttpGetAsync("http://localhost:8500/api/test/TestGet?val=" + val);
60.                 Log("异步  返回数据" + result + "  线程ID：" + Thread.CurrentThread.ManagedThreadId);
61.             }
62.             catch (Exception ex)
63.             {
64.                 Log("出错：" + ex.Message);
65.             }
66.         }
68.         /// <summary>
69.         /// 在线程中同步请求
70.         /// </summary>
71.         private Task Request(int val)
72.         {
73.             return Task.Run(() =>
74.             {
75.                 try
76.                 {
77.                     Log("同步多线程  开始请求" + val);
78.                     string result = HttpUtil.HttpGet("http://localhost:8500/api/test/TestGet?val=" + val);
79.                     Log("同步多线程  返回数据" + result + "  线程ID：" + Thread.CurrentThread.ManagedThreadId);
80.                 }
81.                 catch (Exception ex)
82.                 {
83.                     Log("出错：" + ex.Message);
84.                 }
85.             });
86.         }
88.         //测试异步请求
89.         private async void button3_Click(object sender, EventArgs e)
90.         {
91.             textBox1.Text = string.Empty;
92.             Stopwatch sw = new Stopwatch();
93.             List<Task> taskList = new List<Task>();
94.             sw.Start();
96.             for (int i = 0; i < n; i++)
97.             {
98.                 Task t = ReqeustAsync(i);
99.                 taskList.Add(t);
100.             }
101.             foreach (Task t in taskList)
102.             {
103.                 await t;
104.             }
106.             Log(n + "个异步请求完成，耗时：" + sw.Elapsed.TotalSeconds.ToString("0.000"));
107.             sw.Stop();
108.         }
110.         //测试多线程同步请求
111.         private void button4_Click(object sender, EventArgs e)
112.         {
113.             textBox1.Text = string.Empty;
115.             Task.Run(() =>
116.             {
117.                 List<Task> taskList = new List<Task>();
118.                 Stopwatch sw = new Stopwatch();
119.                 sw.Start();
121.                 for (int i = 0; i < n; i++)
122.                 {
123.                     Task t = Request(i);
124.                     taskList.Add(t);
125.                 }
126.                 Task.WaitAll(taskList.ToArray());
128.                 Log(n + "个多线程同步请求完成，耗时：" + sw.Elapsed.TotalSeconds.ToString("0.000"));
129.                 sw.Stop();
130.             });
131.         }
132.     }
133. }

复制代码

测试结果


性能差9倍！
把WebAPI接口中模拟执行耗时操作改成1000毫秒再测试，测试结果如下：

性能差10倍！
把Form1.cs构造函数中添加一行ThreadPool.SetMinThreads(20, 20);再测：

设置线程池中线程的最小数量为20后，性能差距缩小了，性能只差4倍！为什么？没有设置线程池最小数量时，大约每1秒增加1到2个线程，线程增加速度太慢了，不影响协程性能，协程只需要很少的线程数量，但影响多线程性能。
把Form1.cs构造函数中代码修改成ThreadPool.SetMinThreads(200, 200);再测：

当线程池中线程数量足够多时，性能差不多了！
结论

通过这个形象的例子，你体会到协程的好处了吗？
有人可能会说，你怎么不把WebAPI端改成异步试试？WebAPI端是模拟的操作，在没有外部操作(IO操作、数据库操作等)，仅有数据计算时，WebAPI端改成异步没区别。
有一个截图中没有体验出来的，测试过程中，对于协程测试，工作线程和异步线程始终为0，我想异步线程应该是变化的，可能只是变化太快，看不出来。而多线程测试，测试过程中，我们可以看到工作线程的数量是大于0的，维持在一定数量，直到请求完成，也就是说，测试过程中，要占用一定数量的工作线程。
所以结论是什么？
协程在执行耗时请求时，不会占用线程(注意占用这个词，它肯定是使用线程的，但不会在耗时请求过程中占用)，在线程池中线程数量较少时，协程的性能比多线程好很多。想一想，要是IO操作、数据库操作，存在一些慢查询、超时的，如果你使用多线程，你的线程池就爆了，协程就不会(Talk is cheap, show me the code!)，后面附上测试。
WebAPI服务端补充说明

上面的测试，服务端我忘了说了，服务端启动服务前，我加了一行代码ThreadPool.SetMinThreads(200, 200);，因为你测试客户端之前，服务端性能要跟上，不然测了个寂寞。
如果我把这行代码删掉，预热后，再测：

可以看到差距只有2.5倍了！因为服务端线程数量此时是1秒增加1、2个线程，服务端性能跟不上，客户端的异步请求自然也快不起来。
爆线程池测试

测试前修改：

• 把WebAPI接口中模拟执行耗时操作改成2000000毫秒，模拟服务端性能不行，反应慢。
  
• ThreadPool.SetMinThreads(20, 20);客户端线程池最小线程数量设置为20，当然线程池越大越不容易爆，这里为了更快重现出来，所以设置小一点，注意，我可没有设置线程池上限！只是设置了下限。
  

测试视频：
注意看测试时工作线程数量：

说明：协程，不论什么时候点，都会有响应，当然可能后面点多了会报错，但即使报错，响应是有的。而多线程，后面点的，响应就很慢了。

你们可能会说你设置的线程池最小线程数量太小，改成ThreadPool.SetMinThreads(200, 200);，再测：

注意看工作线程数量！
附

WebAPI服务启动代码：

1. protected override void OnStart(string[] args)
2. {
3.     ThreadPool.SetMinThreads(200, 200);
5.     int port = int.Parse(ConfigurationManager.AppSettings["WebApiServicePort"]);
6.     StartOptions options = new StartOptions();
7.     options.Urls.Add("http://127.0.0.1:" + port);
8.     options.Urls.Add("http://localhost:" + port);
9.     options.Urls.Add("http://+:" + port);
10.     WebApp.Start<Startup>(options);
11.     LogUtil.Log("Web API 服务 启动成功");
12. }

复制代码

HttpUtil代码：

1. using System;
2. using System.Collections.Generic;
3. using System.IO;
4. using System.Linq;
5. using System.Net;
6. using System.Text;
7. using System.Threading;
8. using System.Threading.Tasks;
10. namespace Utils
11. {
12.     /// <summary>
13.     /// Http上传下载文件
14.     /// </summary>
15.     public class HttpUtil
16.     {
17.         /// <summary>
18.         /// HttpGet
19.         /// </summary>
20.         /// <param name="url">url路径名称</param>
21.         /// <param name="cookie">cookie</param>
22.         public static async Task<string> HttpGetAsync(string url, CookieContainer cookie = null, WebHeaderCollection headers = null)
23.         {
24.             // 设置参数
25.             HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
26.             request.CookieContainer = cookie;
27.             request.Method = "GET";
28.             request.ContentType = "text/plain;charset=utf-8";
29.             request.Timeout = Timeout.Infinite;
31.             if (headers != null)
32.             {
33.                 foreach (string key in headers.Keys)
34.                 {
35.                     request.Headers.Add(key, headers[key]);
36.                 }
37.             }
39.             //发送请求并获取相应回应数据
40.             HttpWebResponse response = (HttpWebResponse)(await request.GetResponseAsync());
41.             //直到request.GetResponse()程序才开始向目标网页发送Post请求
42.             Stream instream = response.GetResponseStream();
43.             StreamReader sr = new StreamReader(instream, Encoding.UTF8);
44.             //返回结果网页（html）代码
45.             string content = await sr.ReadToEndAsync();
46.             instream.Close();
47.             return content;
48.         }
50.         /// <summary>
51.         /// HttpGet
52.         /// </summary>
53.         /// <param name="url">url路径名称</param>
54.         /// <param name="cookie">cookie</param>
55.         public static string HttpGet(string url, CookieContainer cookie = null, WebHeaderCollection headers = null)
56.         {
57.             // 设置参数
58.             HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
59.             request.CookieContainer = cookie;
60.             request.Method = "GET";
61.             request.ContentType = "text/plain;charset=utf-8";
62.             request.Timeout = Timeout.Infinite;
64.             if (headers != null)
65.             {
66.                 foreach (string key in headers.Keys)
67.                 {
68.                     request.Headers.Add(key, headers[key]);
69.                 }
70.             }
72.             //发送请求并获取相应回应数据
73.             HttpWebResponse response = (HttpWebResponse)request.GetResponse();
74.             //直到request.GetResponse()程序才开始向目标网页发送Post请求
75.             Stream instream = response.GetResponseStream();
76.             StreamReader sr = new StreamReader(instream, Encoding.UTF8);
77.             //返回结果网页（html）代码
78.             string content = sr.ReadToEnd();
79.             instream.Close();
80.             return content;
81.         }
82.     }
83. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！