博客园_一线码农

8天玩转并行开发——第六天异步编程模型

2012-05-26T05:21:00Z

在.net里面异步编程模型由来已久，相信大家也知道Begin/End异步模式和事件异步模式，在task出现以后，这些东西都可以被task包装

起来，可能有人会问，这样做有什么好处，下面一一道来。

一： Begin/End模式

1：委托

在执行委托方法的时候，我们常常会看到一个Invoke，同时也有一对你或许不常使用的BeginInvoke，EndInvoke方法对，当然Invoke方法

是阻塞主线程，而BeginInvoke则是另开一个线程。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 var func = new Func<string, string>(i => { return i + "i can fly"; });
6
7 var state = func.BeginInvoke("yes,", Callback, func);
8
9 Console.Read();
10 }
11
12 static void Callback(IAsyncResult async)
13 {
14 var result = async.AsyncState as Func<string, string>;
15
16 Console.WriteLine(result.EndInvoke(async));
17 }
18 }

下面我们用task包装一下

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 var func = new Func<string, string>(i =>
6 {
7 return i + "i can fly";
8 });
9
10 Task<string>.Factory.FromAsync(func.BeginInvoke, func.EndInvoke, "yes,", null).ContinueWith
11 (i =>
12 {
13 Console.WriteLine(i.Result);
14 });
15
16 Console.Read();
17 }
18 }

可以看出，task只要一句就搞定，体现了task的第一个优点：简洁。

2：流

我们发现在Stream抽象类中提供了这样两对BeginRead/EndRead,BeginWrite/EndWrite（异步读写）的方法，这样它的n多继承类都可以

实现异步读写，下面举个继承类FileStream的例子。

1 static void Main(string[] args)
2 {
3 var path = "C://1.txt";
4
5 FileStream fs = new FileStream(path, FileMode.Open);
6
7 FileInfo info = new FileInfo(path);
8
9 byte[] b = new byte[info.Length];
10
11 var asycState = fs.BeginRead(b, 0, b.Length, (result) =>
12 {
13 var file = result.AsyncState as FileStream;
14
15 Console.WriteLine("文件内容：{0}", Encoding.Default.GetString(b));
16
17 file.Close();
18
19 }, fs);
20
21 Console.WriteLine("我是主线程，我不会被阻塞！");
22
23 Console.Read();
24 }

我们用task包装一下

1 static void Main(string[] args)
2 {
3 var path = "C://1.txt";
4
5 FileStream fs = new FileStream(path, FileMode.Open);
6
7 FileInfo info = new FileInfo(path);
8
9 byte[] b = new byte[info.Length];
10
11 Task<int>.Factory.FromAsync(fs.BeginRead, fs.EndRead, b, 0, b.Length, null, TaskCreationOptions.None)
12 .ContinueWith
13 (i =>
14 {
15 Console.WriteLine("文件内容：{0}", Encoding.Default.GetString(b));
16 });
17
18 Console.WriteLine("我是主线程，我不会被阻塞！");
19
20 Console.Read();
21 }

其实看到这里，我们并没有发现task还有其他的什么优点，但是深入的想一下其实并不是这么回事，task能够游刃于线程并发和同步，而原始的异步

编程要实现线程同步还是比较麻烦的。

假如现在有这样的一个需求，我们需要从3个txt文件中读取字符，然后进行倒序，前提是不能阻塞主线程。如果不用task的话我可能会用工作线程

去监视一个bool变量来判断文件是否全部读取完毕，然后再进行倒序，我也说了，相对task来说还是比较麻烦的，这里我就用task来实现。

1 class Program
2 {
3 static byte[] b;
4
5 static void Main()
6 {
7 string[] array = { "C://1.txt", "C://2.txt", "C://3.txt" };
8
9 List<Task<string>> taskList = new List<Task<string>>(3);
10
11 foreach (var item in array)
12 {
13 taskList.Add(ReadAsyc(item));
14 }
15
16 Task.Factory.ContinueWhenAll(taskList.ToArray(), i =>
17 {
18 string result = string.Empty;
19
20 //获取各个task返回的结果
21 foreach (var item in i)
22 {
23 result += item.Result;
24 }
25
26 //倒序
27 String content = new String(result.OrderByDescending(j => j).ToArray());
28
29 Console.WriteLine("倒序结果："+content);
30 });
31
32 Console.WriteLine("我是主线程，我不会被阻塞");
33
34 Console.ReadKey();
35 }
36
37 //异步读取
38 static Task<string> ReadAsyc(string path)
39 {
40 FileInfo info = new FileInfo(path);
41
42 byte[] b = new byte[info.Length];
43
44 FileStream fs = new FileStream(path, FileMode.Open);
45
46 Task<int> task = Task<int>.Factory.FromAsync(fs.BeginRead, fs.EndRead, b, 0, b.Length, null, TaskCreationOptions.None);
47
48 //返回当前task的执行结果
49 return task.ContinueWith(i =>
50 {
51 return i.Result > 0 ? Encoding.Default.GetString(b) : string.Empty;
52 }, TaskContinuationOptions.ExecuteSynchronously);
53 }
54 }

可以看出，task的第二个优点就是：灵活性。

这里可能就有人要问了，能不能用开多个线程用read以同步的形式读取，变相的实现文件异步读取，或许我们可能常听说程序优化后，最后出现的

瓶颈在IO上面，是的，IO是比较耗费资源的，要命的是如果我们开的是工作线程走IO读取文件，那么该线程就会一直处于等待状态，不会再接收任

何的外来请求，直到线程读取到文件为止，那么我们能不能用更少的线程来应对更多的IO操作呢？答案肯定是可以的，这里就设计到了”异步IO“的

概念，具体内容可以参照百科：http://baike.baidu.com/view/1865389.htm ，有幸的是beginXXX,endXXX完美的封装了“异步IO”。

二：事件模式

这个模式常以XXXCompleted的形式结尾，我们在文件下载这一块会经常遇到，这里我也举个例子。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 WebClient client = new WebClient();
6
7 client.DownloadFileCompleted += new System.ComponentModel.AsyncCompletedEventHandler(client_DownloadFileCompleted);
8
9 client.DownloadFileAsync(new Uri("http://imgsrc.baidu.com/baike/abpic/item/6a600c338744ebf844a0bc74d9f9d72a6159a7ac.jpg"),
10 "1.jpg", "图片下完了，你懂的！");
11
12 Console.WriteLine("我是主线程，我不会被阻塞！");
13 Console.Read();
14 }
15
16 static void client_DownloadFileCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
17 {
18 Console.WriteLine("\n" + e.UserState);
19 }
20 }

先前也说了，task是非常灵活的，那么针对这种异步模型，我们该如何封装成task来使用，幸好framework中提供了TaskCompletionSource来帮助

我们快速实现。

1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.IO;
6 using System.Threading.Tasks;
7 using System.Net;
8 using System.ComponentModel;
9
10 namespace ConsoleApplication4
11 {
12 class Program
13 {
14 static void Main()
15 {
16 var downloadTask = DownLoadFileInTask(
17 new Uri(@"http://www.7720mm.cn/uploadfile/2010/1120/20101120073035736.jpg")
18 , "C://1.jpg");
19
20 downloadTask.ContinueWith(i =>
21 {
22 Console.WriteLine("图片:" + i.Result + "下载完毕！");
23 });
24
25 Console.WriteLine("我是主线程，我不会被阻塞!");
26
27 Console.Read();
28 }
29
30 static Task<string> DownLoadFileInTask(Uri address, string saveFile)
31 {
32 var wc = new WebClient();
33
34 var tcs = new TaskCompletionSource<string>(address);
35
36 //处理异步操作的一个委托
37 AsyncCompletedEventHandler handler = null;
38
39 handler = (sender, e) =>
40 {
41 if (e.Error != null)
42 {
43 tcs.TrySetException(e.Error);
44 }
45 else
46 {
47 if (e.Cancelled)
48 {
49 tcs.TrySetCanceled();
50 }
51 else
52 {
53 tcs.TrySetResult(saveFile);
54 }
55 }
56
57 wc.DownloadFileCompleted -= handler;
58 };
59
60 //我们将下载事件与我们自定义的handler进行了关联
61 wc.DownloadFileCompleted += handler;
62
63 try
64 {
65 wc.DownloadFileAsync(address, saveFile);
66 }
67 catch (Exception ex)
68 {
69 wc.DownloadFileCompleted -= handler;
70
71 tcs.TrySetException(ex);
72 }
73
74 return tcs.Task;
75 }
76 }
77 }

本文链接

12篇学通C#网络编程——第三篇 HTTP应用编程（下）

2012-05-20T05:42:00Z

第三篇来的好晚啊，上一篇说了如何向服务器推送信息，这一篇我们看看如何"快好准"的从服务器下拉信息。

网络上有很多大资源文件，比如供人下载的zip包，电影（你懂的），那么我们如何快速的进行下载，大家第一反应肯定就是多线程下载，

那么这些东西是如何做的呢？首先我们可以从“QQ的中转站里面拉一个rar下来“。

然后用fiddler监视一下，我们会发现一个有趣的现象：

第一：7.62*1024*1024≈7990914 千真万确是此文件

第二：我明明是一个http链接，tmd的怎么变成n多个了？有意思。

好，我们继续往下看，看看这些链接都做了些什么？

最终，我们发现http协议中有一个Conent—Range字段，能够把我们的文件总大小进行切分，然后并行下载，最后再进行合并，大概我们知道

了什么原理，那么，我们强大的C#类库提供了AddRange来获取Http中资源的指定范围。

既然进行了切分，那么首先一定要知道文件的ContentLength是多少，如果对http协议比较熟悉的话，当发送一个头信息过去，服务器返回的

头信息中会包含很多东西，此时我们就知道要下载资源的大概情况，这个就有点“兵马未动，粮草先行“的感觉。

1 var request = (HttpWebRequest)HttpWebRequest.Create(url);
2
3 request.Method = "Head";
4
5 request.Timeout = 3000;
6
7 var response = (HttpWebResponse)request.GetResponse();
8
9 var code = response.StatusCode;
10
11 if (code != HttpStatusCode.OK)
12 {
13 Console.WriteLine("下载资源无效！");
14 return;
15 }
16
17 var total = response.ContentLength;

这里有个决策，到底是以下载量来决定线程数，还是以线程数来决定下载量，由于我们的下载取决于当前的网速，所以在这种场合下更好的方案是

采用后者，这几天在闪存里面两次看到苍老师，肃然起敬，所以决定在不用线程和线程的情况下，看看下载仓老师的速度如何。

图片大小(217.27KB)

1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Net;
6 using System.Threading;
7 using System.Threading.Tasks;
8 using System.IO;
9 using System.Collections.Concurrent;
10 using System.Diagnostics;
11 using System.Drawing;
12
13
14 namespace ConsoleApplication1
15 {
16 public class Program
17 {
18 public static CountdownEvent cde = new CountdownEvent(0);
19
20 //每个线程下载的字节数，方便最后合并
21 public static ConcurrentDictionary<long, byte[]> dic = new ConcurrentDictionary<long, byte[]>();
22
23 //请求文件
24 public static string url = "http://www.pncity.net/bbs/data/attachment/forum/201107/30/1901108yyd8gnrs2isadrr.jpg";
25
26 static void Main(string[] args)
27 {
28 for (int i = 0; i < 1; i++)
29 {
30 Console.WriteLine("\n****************************\n第{0}次比较\n****************************", (i + 1));
31
32 //不用线程
33 //RunSingle();
34
35 //使用多线程
36 RunMultiTask();
37 }
38
39 Console.Read();
40 }
41
42 static void RunMultiTask()
43 {
44 Stopwatch watch = Stopwatch.StartNew();
45
46 //开5个线程
47 int threadCount = 5;
48
49 long start = 0;
50
51 long end = 0;
52
53 var total = GetSourceHead();
54
55 if (total == 0)
56 return;
57
58 var pageSize = (int)Math.Ceiling((Double)total / threadCount);
59
60 cde.Reset(threadCount);
61
62 Task[] tasks = new Task[threadCount];
63
64 for (int i = 0; i < threadCount; i++)
65 {
66 start = i * pageSize;
67
68 end = (i + 1) * pageSize - 1;
69
70 if (end > total)
71 end = total;
72
73 var obj = start + "|" + end;
74
75 tasks[i] = Task.Factory.StartNew(j => new DownFile().DownTaskMulti(obj), obj);
76 }
77
78 Task.WaitAll(tasks);
79
80 var targetFile = "C://" + url.Substring(url.LastIndexOf('/') + 1);
81
82 FileStream fs = new FileStream(targetFile, FileMode.Create);
83
84 var result = dic.Keys.OrderBy(i => i).ToList();
85
86 foreach (var item in result)
87 {
88 fs.Write(dic[item], 0, dic[item].Length);
89 }
90
91 fs.Close();
92
93 watch.Stop();
94
95 Console.WriteLine("多线程：下载耗费时间:{0}", watch.Elapsed);
96 }
97
98 static void RunSingle()
99 {
100 Stopwatch watch = Stopwatch.StartNew();
101
102 if (GetSourceHead() == 0)
103 return;
104
105 var request = (HttpWebRequest)HttpWebRequest.Create(url);
106
107 var response = (HttpWebResponse)request.GetResponse();
108
109 var stream = response.GetResponseStream();
110
111 var outStream = new MemoryStream();
112
113 var bytes = new byte[10240];
114
115 int count = 0;
116
117 while ((count = stream.Read(bytes, 0, bytes.Length)) != 0)
118 {
119 outStream.Write(bytes, 0, count);
120 }
121
122 var targetFile = "C://" + url.Substring(url.LastIndexOf('/') + 1);
123
124 FileStream fs = new FileStream(targetFile, FileMode.Create);
125
126 fs.Write(outStream.ToArray(), 0, (int)outStream.Length);
127
128 outStream.Close();
129
130 response.Close();
131
132 fs.Close();
133
134 watch.Stop();
135
136 Console.WriteLine("不用线程：下载耗费时间:{0}", watch.Elapsed);
137 }
138
139 //获取头信息
140 public static long GetSourceHead()
141 {
142 var request = (HttpWebRequest)HttpWebRequest.Create(url);
143
144 request.Method = "Head";
145 request.Timeout = 3000;
146
147 var response = (HttpWebResponse)request.GetResponse();
148
149 var code = response.StatusCode;
150
151 if (code != HttpStatusCode.OK)
152 {
153 Console.WriteLine("下载的资源无效！");
154 return 0;
155 }
156
157 var total = response.ContentLength;
158
159 Console.WriteLine("当前资源大小为:" + total);
160
161 response.Close();
162
163 return total;
164 }
165 }
166
167 public class DownFile
168 {
169 // 多线程下载
170 public void DownTaskMulti(object obj)
171 {
172 var single = obj.ToString().Split('|');
173
174 long start = Convert.ToInt64(single.FirstOrDefault());
175
176 long end = Convert.ToInt64(single.LastOrDefault());
177
178 var request = (HttpWebRequest)HttpWebRequest.Create(Program.url);
179
180 request.AddRange(start, end);
181
182 var response = (HttpWebResponse)request.GetResponse();
183
184 var stream = response.GetResponseStream();
185
186 var outStream = new MemoryStream();
187
188 var bytes = new byte[10240];
189
190 int count = 0;
191
192 while ((count = stream.Read(bytes, 0, bytes.Length)) != 0)
193 {
194 outStream.Write(bytes, 0, count);
195 }
196
197 outStream.Close();
198
199 response.Close();
200
201 Program.dic.TryAdd(start, outStream.ToArray());
202
203 Program.cde.Signal();
204 }
205 }
206 }

在下面的图中可以看出，我们的资源被分成了n段，在217.27KB的情况下，多线程加速还不是很明显，我们可以试试更大的文件，这里我就

在本地放一个133M的rar文件。

//请求文件
public static string url = "http://localhost:56933/1.rar";

现在看一下效果是非常明显的。

本文链接

lucene，你也会(7篇）——第一篇快速入门

2012-05-12T16:53:00Z

日常开发中，相信大家经常会用like去匹配一些数据，同时我们也知道，like往往会导致全表扫描，当数据量越来越大的时候，我们会纠结于

数据库的龟速查找，此时我们必须另寻蹊跷，这时lucene就可以大显身手了。

首先我们做一个demo，向数据库中插入10w条数据，总共778M。

接下来，我们搜索下新闻内容中包含“流行”的记录。

mmd，检索一下要78s，是谁都要砸了面前的破机子。

下面我们来看看lucene的效果怎么样。下载地址：http://incubator.apache.org/lucene.net/download.html

1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using Lucene.Net.Index;
6 using Lucene.Net.Store;
7 using Lucene.Net.Analysis.Standard;
8 using Lucene.Net.Documents;
9 using System.Data;
10 using System.Diagnostics;
11 using Lucene.Net.Search;
12
13 using Lucene.Net.QueryParsers;
14
15 namespace First
16 {
17 class Program
18 {
19 static string path = @"D:\Sample";
20
21 static void Main(string[] args)
22 {
23 //创建索引
24 CreateIndex();
25
26 var watch = Stopwatch.StartNew();
27
28 //搜索
29 IndexSearcher search = new IndexSearcher(path);
30
31 //查询表达式
32 QueryParser query = new QueryParser(string.Empty, new StandardAnalyzer());
33
34 //query.parse：注入查询条件
35 var hits = search.Search(query.Parse("Content:流行"));
36
37 for (int i = 0; i < hits.Length(); i++)
38 {
39 Console.WriteLine("当前内容:{0}", hits.Doc(i).Get("Content").Substring(0, 20) + "...");
40 }
41
42 watch.Stop();
43
44 Console.WriteLine("搜索耗费时间:{0}", watch.ElapsedMilliseconds);
45 }
46
47 static void CreateIndex()
48 {
49 //创建索引库目录
50 var directory = FSDirectory.GetDirectory(path, true);
51
52 //创建一个索引,采用StandardAnalyzer对句子进行分词
53 IndexWriter indexWriter = new IndexWriter(directory, new StandardAnalyzer());
54
55 var reader = DbHelperSQL.ExecuteReader("select * from News");
56
57 while (reader.Read())
58 {
59 //域的集合：文档，类似于表的行
60 Document doc = new Document();
61
62 //要索引的字段
63 doc.Add(new Field("ID", reader["ID"].ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED));
64 doc.Add(new Field("Title", reader["Title"].ToString(), Field.Store.NO, Field.Index.ANALYZED));
65 doc.Add(new Field("Content", reader["Content"].ToString(), Field.Store.YES, Field.Index.ANALYZED));
66
67 indexWriter.AddDocument(doc);
68 }
69
70 reader.Close();
71
72 //对索引文件进行优化
73 indexWriter.Optimize();
74
75 indexWriter.Close();
76 }
77 }
78 }

我靠，448ms，顿时78s黯然失色，当然这个时间是不包含"创建索引“的时间，从时间复杂度上来说，这种预加载索引算是常量。

作为入门，简单的介绍下lucene的实现过程，首先lucene主要分成两步："索引"和"搜索"。

一：索引：

相信大家对索引还是比较熟悉的，lucene能够将我们内容切分成很多词，然后将词作为key，建立“倒排索引”，然后放到索引库中，在上面

的例子中，我们看到了索引过程中使用到了IndexWriter，FSDirectory，StandardAnalyzer，Document和Field这些类，下面简要分析下。

1：IndexWriter

我们看到该类有一个AddDocument方法，所以我们认为该类实现了索引的写入操作。

2：FSDirectory

这个就更简单了，提供了索引库的存放位置，比如我们这里的D:\Sample，或许有人问，能不能存放在内存中，在强大的lucene面前当然

可以做到，lucene中的RAMDirectory就可以实现，当然我们的内存足够大的话，还是可以用内存承载索引库，进而提高搜索的效率。

3：StandardAnalyzer

这个算是索引过程中最最关键的一步，也是我们使用lucene非常慎重考虑的东西，之所以我们能搜索秒杀，关键在于我们如何将输入的内容

进行何种形式的切分，当然不同的切分形式诞生了不同的分析器，StandardAnalyzer就是一个按照单字分词的一种分析器，详细的介绍后续文

章分享。

4：Document

在上面的例子可以看到，他是承载field的集合，然后添加到IndexWriter中，有点类似表中的行的概念。

5: Field

提供了对要分析的字段进行何种处理，以KV形式呈现。

①：Field.Store.YES， Field.Index.NOT_ANALYZED 表示对索引字段采取：原样保存并且不被StandardAnalyzer进行切分。

②： Field.Store.NO, Field.Index.ANALYZED 不保存但是要被StandardAnalyzer切分。

二：搜索

这个比较容易，根据我们输入的词lucene能够在索引库中快速定位到我们要找的词，同样我们可以看到IndexSearcher，QueryParser，Hits。

1：IndexSearcher

这个我们可以理解成以只读的形式打开由IndexWriter创建的索引库，search给QueryParser提供了查询的桥梁。

2：QueryParser

这玩意提供了一个parse方法能够将我们要查找的词转化为lucene能够理解了查询表达式。

3：Hits

这个就是获取匹配结果的一个指针，优点类似C#中的延迟加载，目的都是一样，提高性能。

好了，大体上也就这样，时间不早了，洗洗睡了。嘻嘻。

本文链接

8天玩转并行开发——第五天同步机制（下）

2012-04-08T07:53:00Z

承接上一篇，我们继续说下.net4.0中的同步机制，是的，当出现了并行计算的时候，轻量级别的同步机制应运而生，在信号量这一块

出现了一系列的轻量级，今天继续介绍下面的3个信号量 CountdownEvent，SemaphoreSlim，ManualResetEventSlim。

一：CountdownEvent

这种采用信号状态的同步基元非常适合在动态的fork,join的场景，它采用“信号计数”的方式，就比如这样，一个麻将桌只能容纳4个

人打麻将，如果后来的人也想搓一把碰碰运气，那么他必须等待直到麻将桌上的人走掉一位。好，这就是简单的信号计数机制，从技术角

度上来说它是定义了最多能够进入关键代码的线程数。

但是CountdownEvent更牛X之处在于我们可以动态的改变“信号计数”的大小，比如一会儿能够容纳8个线程，一下又4个，一下又10个，

这样做有什么好处呢？还是承接上一篇文章所说的，比如一个任务需要加载1w条数据，那么可能出现这种情况。

加载User表：根据user表的数据量，我们需要开5个task。

加载Product表：产品表数据相对比较多，计算之后需要开8个task。

加载order表：由于我的网站订单丰富，计算之后需要开12个task。

先前的文章也说了，我们需要协调task在多阶段加载数据的同步问题，那么如何应对这里的5，8，12，幸好，CountdownEvent给我们提供了

可以动态修改的解决方案。

1 using System.Collections.Concurrent;
2 using System.Threading.Tasks;
3 using System;
4 using System.Diagnostics;
5 using System.Collections.Generic;
6 using System.Linq;
7 using System.Threading;
8
9 class Program
10 {
11 //默认的容纳大小为“硬件线程“数
12 static CountdownEvent cde = new CountdownEvent(Environment.ProcessorCount);
13
14 static void Main(string[] args)
15 {
16 //加载User表需要5个任务
17 var userTaskCount = 5;
18
19 //重置信号
20 cde.Reset(userTaskCount);
21
22 for (int i = 0; i < userTaskCount; i++)
23 {
24 Task.Factory.StartNew((obj) =>
25 {
26 LoadUser(obj);
27 }, i);
28 }
29
30 //等待所有任务执行完毕
31 cde.Wait();
32
33 Console.WriteLine("\nUser表数据全部加载完毕！\n");
34
35 //加载product需要8个任务
36 var productTaskCount = 8;
37
38 //重置信号
39 cde.Reset(productTaskCount);
40
41 for (int i = 0; i < productTaskCount; i++)
42 {
43 Task.Factory.StartNew((obj) =>
44 {
45 LoadProduct(obj);
46 }, i);
47 }
48
49 cde.Wait();
50
51 Console.WriteLine("\nProduct表数据全部加载完毕！\n");
52
53 //加载order需要12个任务
54 var orderTaskCount = 12;
55
56 //重置信号
57 cde.Reset(orderTaskCount);
58
59 for (int i = 0; i < orderTaskCount; i++)
60 {
61 Task.Factory.StartNew((obj) =>
62 {
63 LoadOrder(obj);
64 }, i);
65 }
66
67 cde.Wait();
68
69 Console.WriteLine("\nOrder表数据全部加载完毕！\n");
70
71 Console.WriteLine("\n(*^__^*) 嘻嘻，恭喜你，数据全部加载完毕\n");
72
73 Console.Read();
74 }
75
76 static void LoadUser(object obj)
77 {
78 try
79 {
80 Console.WriteLine("当前任务:{0}正在加载User部分数据！", obj);
81 }
82 finally
83 {
84 cde.Signal();
85 }
86 }
87
88 static void LoadProduct(object obj)
89 {
90 try
91 {
92 Console.WriteLine("当前任务:{0}正在加载Product部分数据！", obj);
93 }
94 finally
95 {
96 cde.Signal();
97 }
98 }
99
100 static void LoadOrder(object obj)
101 {
102 try
103 {
104 Console.WriteLine("当前任务:{0}正在加载Order部分数据！", obj);
105 }
106 finally
107 {
108 cde.Signal();
109 }
110 }
111 }

我们看到有两个主要方法：Wait和Signal。每调用一次Signal相当于麻将桌上走了一个人，直到所有人都搓过麻将wait才给放行，这里同样要

注意也就是“超时“问题的存在性，尤其是在并行计算中，轻量级别给我们提供了”取消标记“的机制，这是在重量级别中不存在的，比如下面的

重载public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)，具体使用可以看前一篇文章的介绍。

二：SemaphoreSlim

在.net 4.0之前，framework中有一个重量级的Semaphore，人家可以跨进程同步，咋轻量级不行，msdn对它的解释为：限制可同时访问

某一资源或资源池的线程数。关于它的重量级demo，我的上一个系列有演示，你也可以理解为CountdownEvent是 SemaphoreSlim的功能加

强版，好了，举一个轻量级使用的例子。

同样，防止死锁的情况，我们需要知道”超时和取消标记“的解决方案，像SemaphoreSlim这种定死的”线程请求范围“，其实是降低了扩展性，

所以说，试水有风险，使用需谨慎，在觉得有必要的时候使用它。

三： ManualResetEventSlim

相信它的重量级别大家都知道是ManualReset，而这个轻量级别采用的是"自旋等待“+”内核等待“，也就是说先采用”自旋等待的方式“等待，

直到另一个任务调用set方法来释放它。如果迟迟等不到释放，那么任务就会进入基于内核的等待，所以说如果我们知道等待的时间比较短，采

用轻量级的版本会具有更好的性能，原理大概就这样，下面举个小例子。

本文链接

8天玩转并行开发——第四天同步机制（上）

2012-04-07T15:07:00Z

在并行计算中，不可避免的会碰到多个任务共享变量，实例，集合。虽然task自带了两个方法：task.ContinueWith()和Task.Factory

.ContinueWhenAll()来实现任务串行化，但是这些简单的方法远远不能满足我们实际的开发需要，从.net 4.0开始，类库给我们提供了很多

的类来帮助我们简化并行计算中复杂的数据同步问题。

大体上分为二种：

① 并发集合类: 这个在先前的文章中也用到了，他们的出现不再让我们过多的关注同步细节。

② 轻量级同步机制: 相对于老版本中那些所谓的重量级同步机制而言,新的机制更加节省cpu的额外开销。

关于并发集合类没什么好讲的，如果大家熟悉非线程安全的集合，那么这些并发的集合对你来说小菜一碟，这一篇和下一篇我们仔细来玩玩这

些轻量级的同步机制。

一：Barrier（屏障同步）

1：基本概念

msdn对它的解释是：使多个任务能够采用并行方式依据某种算法在多个阶段中协同工作。乍一看有点不懂，没关系，我们采取提干法。

”多个任务“，”多个阶段”，“协同”，仔细想想知道了，下一阶段的执行必须等待上一个阶段中多task全部执行完，那么我们实际中有这样

的需求吗？当然有的，比如我们数据库中有100w条数据需要导入excel，为了在数据库中加速load，我们需要开多个任务去跑，比如这

里的4个task，要想load产品表，必须等4个task都跑完用户表才行，那么你有什么办法可以让task为了你两肋插刀呢？它就是Barrier。

好，我们知道barrier叫做屏障，就像下图中的“红色线”，如果我们的屏障设为4个task就认为已经满了的话，那么执行中先到的task必须等待

后到的task，通知方式也就是barrier.SignalAndWait()，屏障中线程设置操作为new Barrier(4,(i)=>{})。

啰嗦了半天，还是上下代码说话：

2：死锁问题

先前的例子我们也知道，屏障必须等待4个task通过SignalAndWait()来告知自己已经到达，当4个task全部达到后，我们可以通过

barrier.ParticipantsRemaining来获取task到达状态，那么如果有一个task久久不能到达那会是怎样的情景呢？好，我举个例子。

1 using System.Collections.Concurrent;
2 using System.Threading.Tasks;
3 using System;
4 using System.Diagnostics;
5 using System.Collections.Generic;
6 using System.Linq;
7 using System.Threading;
8
9 class Program
10 {
11 //四个task执行
12 static Task[] tasks = new Task[4];
13
14 static Barrier barrier = null;
15
16 static void Main(string[] args)
17 {
18 barrier = new Barrier(tasks.Length, (i) =>
19 {
20 Console.WriteLine("**********************************************************");
21 Console.WriteLine("\n屏障中当前阶段编号:{0}\n", i.CurrentPhaseNumber);
22 Console.WriteLine("**********************************************************");
23 });
24
25 for (int j = 0; j < tasks.Length; j++)
26 {
27 tasks[j] = Task.Factory.StartNew((obj) =>
28 {
29 var single = Convert.ToInt32(obj);
30
31 LoadUser(single);
32 barrier.SignalAndWait();
33
34 LoadProduct(single);
35 barrier.SignalAndWait();
36
37 LoadOrder(single);
38 barrier.SignalAndWait();
39
40 }, j);
41 }
42
43 Task.WaitAll(tasks);
44
45 barrier.Dispose();
46
47 Console.WriteLine("指定数据库中所有数据已经加载完毕！");
48
49 Console.Read();
50 }
51
52 static void LoadUser(int num)
53 {
54 Console.WriteLine("\n当前任务:{0}正在加载User部分数据！", num);
55
56 if (num == 0)
57 {
58 //num=0：表示0号任务
59 //barrier.ParticipantsRemaining == 0：表示所有task到达屏障才会退出
60 // SpinWait.SpinUntil: 自旋锁，相当于死循环
61 SpinWait.SpinUntil(() => barrier.ParticipantsRemaining == 0);
62 }
63 }
64
65 static void LoadProduct(int num)
66 {
67 Console.WriteLine("当前任务:{0}正在加载Product部分数据！", num);
68 }
69
70 static void LoadOrder(int num)
71 {
72 Console.WriteLine("当前任务:{0}正在加载Order部分数据！", num);
73 }
74 }

我们发现程序在加载User表的时候卡住了，出现了类似死循环，这句SpinWait.SpinUntil(() => barrier.ParticipantsRemaining == 0)中

的ParticipantsRemaining==0 永远也不能成立，导致task0永远都不能退出，然而barrier还在一直等待task0调用SignalAndWait来结束屏障。

结果就是造成了相互等待的尴尬局面,我们下个断点看看情况。

3：超时机制

当我们coding的时候遇到了这种问题还是很纠结的，所以我们必须引入一种“超时机制”，如果在指定的时候内所有的参与者（task）都

没有到达屏障的话，我们就需要取消这些参与者的后续执行，幸好SignalAndWait给我们提供了超时的重载，为了能够取消后续执行，我们

还要采用CancellationToken机制。

1 using System.Collections.Concurrent;
2 using System.Threading.Tasks;
3 using System;
4 using System.Diagnostics;
5 using System.Collections.Generic;
6 using System.Linq;
7 using System.Threading;
8
9 class Program
10 {
11 //四个task执行
12 static Task[] tasks = new Task[4];
13
14 static Barrier barrier = null;
15
16 static void Main(string[] args)
17 {
18 CancellationTokenSource cts = new CancellationTokenSource();
19
20 CancellationToken ct = cts.Token;
21
22 barrier = new Barrier(tasks.Length, (i) =>
23 {
24 Console.WriteLine("**********************************************************");
25 Console.WriteLine("\n屏障中当前阶段编号:{0}\n", i.CurrentPhaseNumber);
26 Console.WriteLine("**********************************************************");
27 });
28
29 for (int j = 0; j < tasks.Length; j++)
30 {
31 tasks[j] = Task.Factory.StartNew((obj) =>
32 {
33 var single = Convert.ToInt32(obj);
34
35 LoadUser(single);
36
37 if (!barrier.SignalAndWait(2000))
38 {
39 //抛出异常，取消后面加载的执行
40 throw new OperationCanceledException(string.Format("我是当前任务{0},我抛出异常了！", single), ct);
41 }
42
43 LoadProduct(single);
44 barrier.SignalAndWait();
45
46 LoadOrder(single);
47 barrier.SignalAndWait();
48
49 }, j, ct);
50 }
51
52 //等待所有tasks 4s
53 Task.WaitAll(tasks, 4000);
54
55 try
56 {
57 for (int i = 0; i < tasks.Length; i++)
58 {
59 if (tasks[i].Status == TaskStatus.Faulted)
60 {
61 //获取task中的异常
62 foreach (var single in tasks[i].Exception.InnerExceptions)
63 {
64 Console.WriteLine(single.Message);
65 }
66 }
67 }
68
69 barrier.Dispose();
70 }
71 catch (AggregateException e)
72 {
73 Console.WriteLine("我是总异常:{0}", e.Message);
74 }
75
76 Console.Read();
77 }
78
79 static void LoadUser(int num)
80 {
81 Console.WriteLine("\n当前任务:{0}正在加载User部分数据！", num);
82
83 if (num == 0)
84 {
85 //自旋转5s
86 if (!SpinWait.SpinUntil(() => barrier.ParticipantsRemaining == 0, 5000))
87 return;
88 }
89
90 Console.WriteLine("当前任务:{0}正在加载User数据完毕！", num);
91 }
92
93 static void LoadProduct(int num)
94 {
95 Console.WriteLine("当前任务:{0}正在加载Product部分数据！", num);
96 }
97
98 static void LoadOrder(int num)
99 {
100 Console.WriteLine("当前任务:{0}正在加载Order部分数据！", num);
101 }
102 }

二：spinLock（自旋锁）

我们初识多线程或者多任务时，第一个想到的同步方法就是使用lock或者Monitor，然而在4.0 之后给我们提供了另一把武器spinLock，

如果你的任务持有锁的时间非常短，具体短到什么时候msdn也没有给我们具体的答案，但是有一点值得确定的时，如果持有锁的时候比较

短，那么它比那些重量级别的Monitor具有更小的性能开销，它的用法跟Monitor很相似，下面举个例子，Add2方法采用自旋锁。

1 using System.Collections.Concurrent;
2 using System.Threading.Tasks;
3 using System;
4 using System.Diagnostics;
5 using System.Collections.Generic;
6 using System.Linq;
7 using System.Threading;
8
9 class Program
10 {
11 static SpinLock slock = new SpinLock(false);
12
13 static int sum1 = 0;
14
15 static int sum2 = 0;
16
17 static void Main(string[] args)
18 {
19 Task[] tasks = new Task[100];
20
21 for (int i = 1; i <= 100; i++)
22 {
23 tasks[i - 1] = Task.Factory.StartNew((num) =>
24 {
25 Add1((int)num);
26
27 Add2((int)num);
28
29 }, i);
30 }
31
32 Task.WaitAll(tasks);
33
34 Console.WriteLine("Add1数字总和:{0}", sum1);
35
36 Console.WriteLine("Add2数字总和:{0}", sum2);
37
38 Console.Read();
39 }
40
41 //无锁
42 static void Add1(int num)
43 {
44 Thread.Sleep(100);
45
46 sum1 += num;
47 }
48
49 //自旋锁
50 static void Add2(int num)
51 {
52 bool lockTaken = false;
53
54 Thread.Sleep(100);
55
56 try
57 {
58 slock.Enter(ref lockTaken);
59 sum2 += num;
60 }
61 finally
62 {
63 if (lockTaken)
64 slock.Exit(false);
65 }
66 }
67 }

本文链接

8天玩转并行开发——第三天 plinq的使用

2012-04-03T17:05:00Z

相信在.net平台下，我们都玩过linq，是的，linq让我们的程序简洁优美，简直玩的是爱不释手，但是传统的linq只是串行代码，在并行的

年代如果linq不支持并行计算那该是多么遗憾的事情啊。

当然linq有很多种方式，比如linq to sql ,xml，object 等等，如果要将linq做成并行还是很简单的，这里我就举一个比较实际一点的例子，

我们知道为了更快的响应用户操作，码农们想尽了各种办法，绞尽了脑汁，其中有一个办法就是将数据库数据预加载到内存中，然后通过各种

数据结构的手段来加速CURD，是的，比如一个排序地球人只能做到N(lgN)，那么如果我还想再快一点的话该怎么办呢？那么现在的并行就能发

挥巨大的优势，尤其是现在的服务器配置都是在8个硬件线程的情况下，你简直会狂笑好几天啊，好，不乱扯了。

1：AsParallel(并行化）

下面我们模拟给ConcurrentDictionary灌入1500w条记录，看看串行和并行效率上的差异，注意我的老爷机是2个硬件线程。

1 using System;
2 using System.Threading;
3 using System.Threading.Tasks;
4 using System.Diagnostics;
5 using System.Collections.Concurrent;
6 using System.Collections.Generic;
7
8 using System.Linq;
9
10 class Program
11 {
12 static void Main(string[] args)
13 {
14 var dic = LoadData();
15
16 Stopwatch watch = new Stopwatch();
17
18 watch.Start();
19
20 //串行执行
21 var query1 = (from n in dic.Values
22 where n.Age > 20 && n.Age < 25
23 select n).ToList();
24
25 watch.Stop();
26
27 Console.WriteLine("串行计算耗费时间：{0}", watch.ElapsedMilliseconds);
28
29 watch.Restart();
30
31 var query2 = (from n in dic.Values.AsParallel()
32 where n.Age > 20 && n.Age < 25
33 select n).ToList();
34
35 watch.Stop();
36
37 Console.WriteLine("并行计算耗费时间：{0}", watch.ElapsedMilliseconds);
38
39 Console.Read();
40 }
41
42 public static ConcurrentDictionary<int, Student> LoadData()
43 {
44 ConcurrentDictionary<int, Student> dic = new ConcurrentDictionary<int, Student>();
45
46 //预加载1500w条记录
47 Parallel.For(0, 15000000, (i) =>
48 {
49 var single = new Student()
50 {
51 ID = i,
52 Name = "hxc" + i,
53 Age = i % 151,
54 CreateTime = DateTime.Now.AddSeconds(i)
55 };
56 dic.TryAdd(i, single);
57 });
58
59 return dic;
60 }
61
62 public class Student
63 {
64 public int ID { get; set; }
65
66 public string Name { get; set; }
67
68 public int Age { get; set; }
69
70 public DateTime CreateTime { get; set; }
71 }
72 }

执行的结果还是比较震撼的，将近7倍，这是因为plinq的查询引擎会尽量利用cpu的所有硬件线程。

2:常用方法的使用

<1> orderby

有时候我们并不是简单的select一下就ok了，可能需要将结果进行orderby操作，并行化引擎会把要遍历的数据分区，然后在每个区上进行

orderby操作，最后来一个总的orderby，这里很像算法中的“归并排序”。

1 using System;
2 using System.Threading;
3 using System.Threading.Tasks;
4 using System.Diagnostics;
5 using System.Collections.Concurrent;
6 using System.Collections.Generic;
7
8 using System.Linq;
9
10 class Program
11 {
12 static void Main(string[] args)
13 {
14 var dic = LoadData();
15
16 var query1 = (from n in dic.Values.AsParallel()
17 where n.Age > 20 && n.Age < 25
18 select n).ToList();
19
20
21 Console.WriteLine("默认的时间排序如下：");
22 query1.Take(10).ToList().ForEach((i) =>
23 {
24 Console.WriteLine(i.CreateTime);
25 });
26
27 var query2 = (from n in dic.Values.AsParallel()
28 where n.Age > 20 && n.Age < 25
29 orderby n.CreateTime descending
30 select n).ToList();
31
32 Console.WriteLine("排序后的时间排序如下：");
33 query2.Take(10).ToList().ForEach((i) =>
34 {
35 Console.WriteLine(i.CreateTime);
36 });
37
38 Console.Read();
39 }
40
41 public static ConcurrentDictionary<int, Student> LoadData()
42 {
43 ConcurrentDictionary<int, Student> dic = new ConcurrentDictionary<int, Student>();
44
45 //预加载1500w条记录
46 Parallel.For(0, 15000000, (i) =>
47 {
48 var single = new Student()
49 {
50 ID = i,
51 Name = "hxc" + i,
52 Age = i % 151,
53 CreateTime = DateTime.Now.AddSeconds(i)
54 };
55 dic.TryAdd(i, single);
56 });
57
58 return dic;
59 }
60
61 public class Student
62 {
63 public int ID { get; set; }
64
65 public string Name { get; set; }
66
67 public int Age { get; set; }
68
69 public DateTime CreateTime { get; set; }
70 }
71 }

<2> sum(),average()等等这些聚合函数的效果跟orderby类型一样，都是实现了类型归并排序的效果，这里就不举例子了。

3：指定并行度，这个我在前面文章也说过，为了不让并行计算占用全部的硬件线程，或许可能要留一个线程做其他事情。

1 var query2 = (from n in dic.Values.AsParallel()
2 .WithDegreeOfParallelism(Environment.ProcessorCount - 1)
3 where n.Age > 20 && n.Age < 25
4 orderby n.CreateTime descending
5 select n).ToList();

4：了解ParallelEnumerable类

首先这个类是Enumerable的并行版本，提供了很多用于查询实现的一组方法，截个图，大家看看是不是很熟悉，要记住，他们都是并行的。

下面列举几个简单的例子。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 ConcurrentBag<int> bag = new ConcurrentBag<int>();
6
7 var list = ParallelEnumerable.Range(0, 10000);
8
9 list.ForAll((i) =>
10 {
11 bag.Add(i);
12 });
13
14 Console.WriteLine("bag集合中元素个数有:{0}", bag.Count);
15
16 Console.WriteLine("list集合中元素个数总和为:{0}", list.Sum());
17
18 Console.WriteLine("list集合中元素最大值为:{0}", list.Max());
19
20 Console.WriteLine("list集合中元素第一个元素为:{0}", list.FirstOrDefault());
21
22 Console.Read();
23 }
24 }

5： plinq实现MapReduce算法

mapReduce是一个非常流行的编程模型，用于大规模数据集的并行计算，非常的牛X啊，记得mongodb中就用到了这个玩意。

map：也就是“映射”操作，可以为每一个数据项建立一个键值对，映射完后会形成一个键值对的集合。

reduce：“化简”操作，我们对这些巨大的“键值对集合“进行分组，统计等等。

具体大家可以看看百科：http://baike.baidu.com/view/2902.htm

下面我举个例子，用Mapreduce来实现一个对age的分组统计。

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Linq;

class Program
{
static void Main(string[] args)
{
List<Student> list = new List<Student>()
{
new Student(){ ID=1, Name="jack", Age=20},
new Student(){ ID=1, Name="mary", Age=25},
new Student(){ ID=1, Name="joe", Age=29},
new Student(){ ID=1, Name="Aaron", Age=25},
};

//这里我们会对age建立一组键值对
var map = list.AsParallel().ToLookup(i => i.Age, count => 1);

//化简统计
var reduce = from IGrouping<int, int> singleMap
in map.AsParallel()
select new
{
Age = singleMap.Key,
Count = singleMap.Count()
};

///最后遍历
reduce.ForAll(i =>
{
Console.WriteLine("当前Age={0}的人数有:{1}人", i.Age, i.Count);
});
}

public class Student
{
public int ID { get; set; }

public string Name { get; set; }

public int Age { get; set; }

public DateTime CreateTime { get; set; }
}
}

本文链接

8天玩转并行开发——第二天 Task的使用

2012-04-02T17:47:00Z

在我们了解Task之前，如果我们要使用多核的功能可能就会自己来开线程，然而这种线程模型在.net 4.0之后被一种称为基于

“任务的编程模型”所冲击，因为task会比thread具有更小的性能开销，不过大家肯定会有疑惑，任务和线程到底有什么区别？

1：任务是架构在线程之上的，也就是说任务最终还是要抛给线程去执行。

2：任务跟线程不是一对一的关系，比如开10个任务并不是说会开10个线程，这一点任务有点类似线程池，但是任务相比线程池有很小

的开销和精确的控制。

一：Task

1. 最简单的使用

开启task有两种方式:

<1> 实例化Task

1 //第一种方式开启
2 var task1 = new Task(() =>
3 {
4 Run1();
5 });

<2>从工厂中创建

1 var task2 = Task.Factory.StartNew(() =>
2 {
3 Run2();
4 });

是的，同样两种方法都可以创建，我们肯定会想两者是不是多多少少有点区别呢？好的，下面我们举个例子看分晓。

1 using System;
2 using System.Threading;
3 using System.Threading.Tasks;
4 using System.Diagnostics;
5 using System.Collections.Generic;
6
7 class Program
8 {
9 static void Main(string[] args)
10 {
11 //第一种方式开启
12 var task1 = new Task(() =>
13 {
14 Run1();
15 });
16
17 //第二种方式开启
18 var task2 = Task.Factory.StartNew(() =>
19 {
20 Run2();
21 });
22
23 Console.WriteLine("调用start之前****************************\n");
24
25 //调用start之前的“任务状态”
26 Console.WriteLine("task1的状态:{0}", task1.Status);
27
28 Console.WriteLine("task2的状态:{0}", task2.Status);
29
30 task1.Start();
31
32 Console.WriteLine("\n调用start之后****************************");
33
34 //调用start之前的“任务状态”
35 Console.WriteLine("\ntask1的状态:{0}", task1.Status);
36
37 Console.WriteLine("task2的状态:{0}", task2.Status);
38
39 //主线程等待任务执行完
40 Task.WaitAll(task1, task2);
41
42 Console.WriteLine("\n任务执行完后的状态****************************");
43
44 //调用start之前的“任务状态”
45 Console.WriteLine("\ntask1的状态:{0}", task1.Status);
46
47 Console.WriteLine("task2的状态:{0}", task2.Status);
48
49 Console.Read();
50 }
51
52 static void Run1()
53 {
54 Thread.Sleep(1000);
55 Console.WriteLine("\n我是任务1");
56 }
57
58 static void Run2()
59 {
60 Thread.Sleep(2000);
61 Console.WriteLine("我是任务2");
62 }
63 }

①：从图中可以看出两种task实例的简略生命周期。

Created：表示默认初始化任务，但是我们发现“工厂创建的”实例直接跳过。

WaitingToRun: 这种状态表示等待任务调度器分配线程给任务执行。

RanToCompletion：任务执行完毕。

②：我们发现task的使用跟Thread很相似，就连waitAll的方法使用也一样，刚才也说了，任务是架构在线程之上，那么我们用VS里面的

“并行任务”看一看，快捷键Ctrl+D，K，或者找到“调试"->"窗口“->"并行任务“，我们在WaitAll方法处插入一个断点，最终我们发现

任务确实托管给了线程。

2. 取消任务

我们知道task是并行计算的，比如说主线程在某个时刻由于某种原因要取消某个task的执行，我们能做到吗? 当然我们可以做到。

在4.0中给我们提供一个“取消标记”叫做CancellationTokenSource.Token，在创建task的时候传入此参数，就可以将主线程和任务相

关联，然后在任务中设置“取消信号“叫做ThrowIfCancellationRequested来等待主线程使用Cancel来通知，一旦cancel被调用。task将会

抛出OperationCanceledException来中断此任务的执行，最后将当前task的Status的IsCanceled属性设为true。看起来是不是很抽象，

没关系，上代码说话。

1 using System;
2 using System.Threading;
3 using System.Threading.Tasks;
4 using System.Diagnostics;
5 class Program
6 {
7 static void Main(string[] args)
8 {
9 var cts = new CancellationTokenSource();
10 var ct = cts.Token;
11
12 Task task1 = new Task(() => { Run1(ct); }, ct);
13
14 Task task2 = new Task(Run2);
15
16 try
17 {
18 task1.Start();
19 task2.Start();
20
21 Thread.Sleep(1000);
22
23 cts.Cancel();
24
25 Task.WaitAll(task1, task2);
26 }
27 catch (AggregateException ex)
28 {
29 foreach (var e in ex.InnerExceptions)
30 {
31 Console.WriteLine("\nhi,我是OperationCanceledException：{0}\n", e.Message);
32 }
33
34 //task1是否取消
35 Console.WriteLine("task1是不是被取消了？ {0}", task1.IsCanceled);
36 Console.WriteLine("task2是不是被取消了？ {0}", task2.IsCanceled);
37 }
38
39 Console.Read();
40 }
41
42 static void Run1(CancellationToken ct)
43 {
44 ct.ThrowIfCancellationRequested();
45
46 Console.WriteLine("我是任务1");
47
48 Thread.Sleep(2000);
49
50 ct.ThrowIfCancellationRequested();
51
52 Console.WriteLine("我是任务1的第二部分信息");
53 }
54
55 static void Run2()
56 {
57 Console.WriteLine("我是任务2");
58 }
59 }

从图中可以看出

①：Run1中的Console.WriteLine("我是任务1的第二部分信息"); 没有被执行。

②：Console.WriteLine("task1是不是被取消了？ {0}", task1.IsCanceled); 状态为True。

也就告诉我们Run1中途被主线程中断执行，我们coding的代码起到效果了。

3. 获取任务的返回值

我们以前写线程的时候注册的方法一般都是void类型，如果主线程要从工作线程中获取数据一般采用的手段是“委托+事件”的模式，然而

在Task中有两种方式可以解决。

<1> 现在我们的实例化是采用Task<TResult>的形式，其中TResult就是当前task执行后返回的结果，下面举得例子是t2任务获取

t1的执行结果。

1 using System;
2 using System.Threading;
3 using System.Threading.Tasks;
4 using System.Diagnostics;
5 using System.Collections.Generic;
6
7 class Program
8 {
9 static void Main(string[] args)
10 {
11 //执行task1
12 var t1 = Task.Factory.StartNew<List<string>>(() => { return Run1(); });
13
14 t1.Wait();
15
16 var t2 = Task.Factory.StartNew(() =>
17 {
18 Console.WriteLine("t1集合中返回的个数：" + string.Join(",", t1.Result));
19 });
20
21 Console.Read();
22 }
23
24 static List<string> Run1()
25 {
26 return new List<string> { "1", "4", "8" };
27 }
28 }

<2>采用ContinueWith方法，很有意思，现在我们将上面的方法改造一下。

1 using System;
2 using System.Threading;
3 using System.Threading.Tasks;
4 using System.Diagnostics;
5 using System.Collections.Generic;
6
7 class Program
8 {
9 static void Main(string[] args)
10 {
11 //执行task1
12 var t1 = Task.Factory.StartNew<List<string>>(() => { return Run1(); });
13
14 var t2 = t1.ContinueWith((i) =>
15 {
16 Console.WriteLine("t1集合中返回的个数：" + string.Join(",", i.Result));
17 });
18
19 Console.Read();
20 }
21
22 static List<string> Run1()
23 {
24 return new List<string> { "1", "4", "8" };
25 }
26 }

4：ContinueWith结合WaitAll来玩一把

当这两者结合起来，我们就可以玩一些复杂一点的东西，比如说现在有7个任务，其中t1需要串行，t2-t3可以并行，t4需要串行，t5-t6并行，

t7串行。

好了，我们上一下代码说话，下面代码没有实际意思，纯属演示。

1 using System;
2 using System.Threading;
3 using System.Threading.Tasks;
4 using System.Diagnostics;
5 using System.Collections.Generic;
6 using System.Collections.Concurrent;
7
8 class Program
9 {
10 static void Main(string[] args)
11 {
12 ConcurrentStack<int> stack = new ConcurrentStack<int>();
13
14 //t1先串行
15 var t1 = Task.Factory.StartNew(() =>
16 {
17 stack.Push(1);
18 stack.Push(2);
19 });
20
21 //t2,t3并行执行
22 var t2 = t1.ContinueWith(t =>
23 {
24 int result;
25
26 stack.TryPop(out result);
27 });
28
29 //t2,t3并行执行
30 var t3 = t1.ContinueWith(t =>
31 {
32 int result;
33
34 stack.TryPop(out result);
35 });
36
37 //等待t2和t3执行完
38 Task.WaitAll(t2, t3);
39
40
41 //t4串行执行
42 var t4 = Task.Factory.StartNew(() =>
43 {
44 stack.Push(1);
45 stack.Push(2);
46 });
47
48 //t5,t6并行执行
49 var t5 = t4.ContinueWith(t =>
50 {
51 int result;
52
53 stack.TryPop(out result);
54 });
55
56 //t5,t6并行执行
57 var t6 = t4.ContinueWith(t =>
58 {
59 int result;
60
61 //只弹出，不移除
62 stack.TryPeek(out result);
63 });
64
65 //临界区：等待t5，t6执行完
66 Task.WaitAll(t5, t6);
67
68 //t7串行执行
69 var t7 = Task.Factory.StartNew(() =>
70 {
71 Console.WriteLine("当前集合元素个数：" + stack.Count);
72 });
73
74 Console.Read();
75 }
76 }

本文链接

8天玩转并行开发——第一天 Parallel的使用

2012-04-01T18:10:00Z

随着多核时代的到来，并行开发越来越展示出它的强大威力，像我们这样的码农再也不用过多的关注底层线程的实现和手工控制，

要了解并行开发，需要先了解下两个概念：“硬件线程”和“软件线程”。

1. 硬件线程

相信大家手头的电脑都是双核以上的，像我这样古董的电脑都是双核的，这样的双核叫做物理内核。

硬件线程又叫做逻辑内核，我们可以在”任务管理器“中查看”性能“标签页，如下图，我们知道有2个硬件线程。

一般情况下，一个物理内核对应一个逻辑内核，比如我这里的2对2。当然如果你的cpu采用的是超线程技术，那么可能就会有4个物理内核对应

8个硬件线程，现在有很多服务器都有8个硬件线程，上午在公司的服务器上截了个图。

我们要知道并行开发要做的事情就是将任务分摊给这些硬件线程去并行执行来达到负载和加速。

2. 软件线程

相信这个大家最熟悉了，我们知道传统的代码都是串行的，就一个主线程，当我们为了实现加速而开了很多工作线程，这些工作线程

也就是软件线程。

好，我们知道了基本概念就ok了，在.net 4.0中，微软给我们提供了一个新的命名空间：System.Threading.Tasks。这里面有很多好玩

的东西，作为第一篇就介绍下最基础，最简单的Parallel的使用。

一： Parallel的使用

在Parallel下面有三个常用的方法invoke,for和forEach。

1: Parallel.Invoke

这是最简单，最简洁的将串行的代码并行化。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 var watch = Stopwatch.StartNew();
6
7 watch.Start();
8
9 Run1();
10
11 Run2();
12
13 Console.WriteLine("我是串行开发，总共耗时:{0}\n", watch.ElapsedMilliseconds);
14
15 watch.Restart();
16
17 Parallel.Invoke(Run1, Run2);
18
19 watch.Stop();
20
21 Console.WriteLine("我是并行开发，总共耗时:{0}", watch.ElapsedMilliseconds);
22
23 Console.Read();
24 }
25
26 static void Run1()
27 {
28 Console.WriteLine("我是任务一,我跑了3s");
29 Thread.Sleep(3000);
30 }
31
32 static void Run2()
33 {
34 Console.WriteLine("我是任务二，我跑了5s");
35 Thread.Sleep(5000);
36 }
37 }

在这个例子中可以获取二点信息：

第一：一个任务是可以分解成多个任务，采用分而治之的思想。

第二：尽可能的避免子任务之间的依赖性，因为子任务是并行执行，所以就没有谁一定在前，谁一定在后的规定了。

2：Parallel.for

我们知道串行代码中也有一个for，但是那个for并没有用到多核，而Paraller.for它会在底层根据硬件线程的运行状况来充分的使用所有的可

利用的硬件线程，注意这里的Parallel.for的步行是1。

这里我们来演示一下，向一个线程安全的集合插入数据，当然这个集合采用原子性来实现线程同步，比那些重量级的锁机制更加的节省消耗。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 for (int j = 1; j < 4; j++)
6 {
7 Console.WriteLine("\n第{0}次比较", j);
8
9 ConcurrentBag<int> bag = new ConcurrentBag<int>();
10
11 var watch = Stopwatch.StartNew();
12
13 watch.Start();
14
15 for (int i = 0; i < 20000000; i++)
16 {
17 bag.Add(i);
18 }
19
20 Console.WriteLine("串行计算：集合有:{0},总共耗时：{1}", bag.Count, watch.ElapsedMilliseconds);
21
22 GC.Collect();
23
24 bag = new ConcurrentBag<int>();
25
26 watch = Stopwatch.StartNew();
27
28 watch.Start();
29
30 Parallel.For(0, 20000000, i =>
31 {
32 bag.Add(i);
33 });
34
35 Console.WriteLine("并行计算：集合有:{0},总共耗时：{1}", bag.Count, watch.ElapsedMilliseconds);
36
37 GC.Collect();
38
39 }
40 }
41 }

可以看的出，加速的效果还是比较明显的。

3：Parallel.forEach
forEach的独到之处就是可以将数据进行分区，每一个小区内实现串行计算，分区采用Partitioner.Create实现。

class Program
{
static void Main(string[] args)
{
for (int j = 1; j < 4; j++)
{
Console.WriteLine("\n第{0}次比较", j);

ConcurrentBag<int> bag = new ConcurrentBag<int>();

var watch = Stopwatch.StartNew();

watch.Start();

for (int i = 0; i < 3000000; i++)
{
bag.Add(i);
}

Console.WriteLine("串行计算：集合有:{0},总共耗时：{1}", bag.Count, watch.ElapsedMilliseconds);

GC.Collect();

bag = new ConcurrentBag<int>();

watch = Stopwatch.StartNew();

watch.Start();

Parallel.ForEach(Partitioner.Create(0, 3000000), i =>
{
for (int m = i.Item1; m < i.Item2; m++)
{
bag.Add(m);
}
});

Console.WriteLine("并行计算：集合有:{0},总共耗时：{1}", bag.Count, watch.ElapsedMilliseconds);

GC.Collect();

}
}
}

这里还是要说一下：Partitioner.Create(0, 3000000)。

第一：我们要分区的范围是0-3000000。

第二：我们肯定想知道系统给我们分了几个区? 很遗憾，这是系统内部协调的，无权告诉我们，当然系统也不反对我们自己指定分区个数，

这里可以使用Partitioner.Create的第六个重载，比如这样：Partitioner.Create(0, 3000000, Environment.ProcessorCount)，

因为 Environment.ProcessorCount能够获取到当前的硬件线程数，所以这里也就开了2个区。

下面分享下并行计算中我们可能有的疑惑？

<1> 如何中途退出并行循环？

是的，在串行代码中我们break一下就搞定了，但是并行就不是这么简单了，不过没关系，在并行循环的委托参数中提供了一个

ParallelLoopState，该实例提供了Break和Stop方法来帮我们实现。

Break: 当然这个是通知并行计算尽快的退出循环，比如并行计算正在迭代100，那么break后程序还会迭代所有小于100的。

Stop：这个就不一样了，比如正在迭代100突然遇到stop，那它啥也不管了，直接退出。

下面举个例子，当迭代到1000的时候退出循环

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 var watch = Stopwatch.StartNew();
6
7 watch.Start();
8
9 ConcurrentBag<int> bag = new ConcurrentBag<int>();
10
11 Parallel.For(0, 20000000, (i, state) =>
12 {
13 if (bag.Count == 1000)
14 {
15 state.Break();
16 return;
17 }
18 bag.Add(i);
19 });
20
21 Console.WriteLine("当前集合有{0}个元素。", bag.Count);
22
23 }
24 }

<2> 并行计算中抛出异常怎么处理？

首先任务是并行计算的，处理过程中可能会产生n多的异常，那么如何来获取到这些异常呢？普通的Exception并不能获取到异常，然而为并行诞生的AggregateExcepation就可以获取到一组异常。

class Program
{
static void Main(string[] args)
{
try
{
Parallel.Invoke(Run1, Run2);
}
catch (AggregateException ex)
{
foreach (var single in ex.InnerExceptions)
{
Console.WriteLine(single.Message);
}
}

Console.Read();
}

static void Run1()
{
Thread.Sleep(3000);
throw new Exception("我是任务1抛出的异常");
}

static void Run2()
{
Thread.Sleep(5000);

throw new Exception("我是任务2抛出的异常");
}
}

<3> 并行计算中我可以留一个硬件线程出来吗？

默认的情况下，底层机制会尽可能多的使用硬件线程，然而我们使用手动指定的好处是我们可以在2，4，8个硬件线程的情况下来进行测量加速比。

class Program
{
static void Main(string[] args)
{
var bag = new ConcurrentBag<int>();

ParallelOptions options = new ParallelOptions();

//指定使用的硬件线程数为1
options.MaxDegreeOfParallelism = 1;

Parallel.For(0, 300000, options, i =>
{
bag.Add(i);
});

Console.WriteLine("并行计算：集合有:{0}", bag.Count);

}
}

本文链接

5天不再惧怕多线程——第五天线程池

2012-03-18T12:30:00Z

说到多线程，不可不说线程池，C#中关于池的概念很多，今天来整理下ThreadPool的使用。

是的，如果你很懒，如果你的执行任务比较短，如果你不想对线程做更精细的控制，那么把这些繁琐的东西丢给线程池吧。

一：ThreadPool

好了，下面看看TheadPool下有哪些常用的方法。

1：GetMaxThreads,GetMinThreads

首先我们肯定好奇线程池到底给我们如何控制线程数，下面就具体的看一看。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 int workerThreads;
6
7 int completePortsThreads;
8
9 ThreadPool.GetMaxThreads(out workerThreads, out completePortsThreads);
10
11 Console.WriteLine("线程池中最大的线程数{0},线程池中异步IO线程的最大数目{1}", workerThreads, completePortsThreads);
12
13 ThreadPool.GetMinThreads(out workerThreads, out completePortsThreads);
14
15 Console.WriteLine("线程池中最小的线程数{0},线程池中异步IO线程的最小数目{1}", workerThreads, completePortsThreads);
16 }
17 }

有的同学可能就要问，我可以将1023设置为10230吗？那么就会有10230个线程帮我做事多好啊，其实不然。

①：我先前的文章也说过，线程很多的话，线程调度就越频繁，可能就会出现某个任务执行的时间比线程调度花费的时间短很多的尴尬局面。

②：我们要知道一个线程默认占用1M的堆栈空间，如果10230个线程将会占用差不多10G的内存空间，我想普通的电脑立马罢工。

2：SetMaxTheads,SetMinThreads

当然，默认的线程设置只是一个参考，如果我们处于性能和实际情况确实需要修改也没关系，framework也给我们提供了现成的方法。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 int workerThreads;
6
7 int completePortsThreads;
8
9 ThreadPool.SetMaxThreads(100, 50);
10
11 ThreadPool.SetMinThreads(20, 10);
12
13 ThreadPool.GetMaxThreads(out workerThreads, out completePortsThreads);
14
15 Console.WriteLine("线程池中最大的线程数{0},线程池中异步IO线程的最大数目{1}\n", workerThreads, completePortsThreads);
16
17 ThreadPool.GetMinThreads(out workerThreads, out completePortsThreads);
18
19 Console.WriteLine("线程池中最小的线程数{0},线程池中异步IO线程的最小数目{1}\n", workerThreads, completePortsThreads);
20 }
21 }

3： QueueUserWorkItem

需要容纳任务并执行的方法来了，该方法有一个WaitCallBack的委托，我们只需要把将要执行的任务丢给委托，CLR将会在线程池中调派空闲的

线程执行。

namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
ThreadPool.QueueUserWorkItem(Run1);

Console.Read();
}

static void Run1(object obj)
{
Console.WriteLine("我是线程{0}，我是线程池中的线程吗？ \n回答：{1}", Thread.CurrentThread.ManagedThreadId,
Thread.CurrentThread.IsThreadPoolThread);
}
}
}

可能我们也需要像普通的Thread一样带一些参数到工作线程中,QueueUserWorkItem的第二个重载版本解决了我们的问题。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 ThreadPool.QueueUserWorkItem(Run1, "我是主线程");
6
7 Console.Read();
8 }
9
10 static void Run1(object obj)
11 {
12 Console.WriteLine(obj);
13 }
14 }

4：RegisterWaitForSingleObject

我们知道，如果我们把要执行的任务丢给线程池后，相当于把自己的命运寄托在别人的手上。

①：我们再也不能控制线程的优先级了。

②：丢给线程池后，我们再也不能将要执行的任务取消了。

是的，给别人就要遵守别人的游戏规则，不过RegisterWaitForSingleObject提供了一些简单的线程间交互，因为该方法的第一个参数是

WaitHandle，在VS对象浏览器中，我们发现EventWaitHandle继承了WaitHandle，而ManualResetEvent和AutoResetEvent都继承于

EventWaitHandle，也就是说我们可以在RegisterWaitForSingleObject溶于信号量的概念。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 AutoResetEvent ar = new AutoResetEvent(false);
6
7 ThreadPool.RegisterWaitForSingleObject(ar, Run1, null, Timeout.Infinite, false);
8
9 Console.WriteLine("时间:{0} 工作线程请注意，您需要等待5s才能执行。\n", DateTime.Now);
10
11 //5s
12 Thread.Sleep(5000);
13
14 ar.Set();
15
16 Console.WriteLine("时间:{0} 工作线程已执行。\n", DateTime.Now);
17
18 Console.Read();
19 }
20
21 static void Run1(object obj, bool sign)
22 {
23 Console.WriteLine("当前时间:{0} 我是线程{1}\n", DateTime.Now, Thread.CurrentThread.ManagedThreadId);
24 }
25 }

我们知道在Threading下面有一个Timer计时器，当定期触发任务的时候都是由线程池提供并给予执行，那么这里我们溶于信号量的概念以后同样

可以实现计时器的功能。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 AutoResetEvent ar = new AutoResetEvent(false);
6
7 //参数2000：其实就是WaitOne(2000)，采取超时机制
8 ThreadPool.RegisterWaitForSingleObject(ar, Run1, null, 2000, false);
9
10 Console.Read();
11 }
12
13 static void Run1(object obj, bool sign)
14 {
15 Console.WriteLine("当前时间:{0} 我是线程{1}\n", DateTime.Now, Thread.CurrentThread.ManagedThreadId);
16 }
17 }
18 }

有时候，跑着跑着我们需要在某个时刻停止它，没关系，RegisterWaitForSingleObject返回一个RegisteredWaitHandle类，那么我们就通过

RegisteredWaitHandle来动态的控制，比如说停止计数器的运行。

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 RegisteredWaitHandle handle = null;
6
7 AutoResetEvent ar = new AutoResetEvent(false);
8
9 handle = ThreadPool.RegisterWaitForSingleObject(ar, Run1, null, 2000, false);
10
11 //10s后停止
12 Thread.Sleep(10000);
13
14 handle.Unregister(ar);
15
16 Console.WriteLine("小子，主线程要干掉你了。");
17
18 Console.Read();
19 }
20
21 static void Run1(object obj, bool sign)
22 {
23 Console.WriteLine("当前时间:{0} 我是线程{1}", DateTime.Now, Thread.CurrentThread.ManagedThreadId);
24 }
25 }

本文链接

5天不再惧怕多线程——第四天信号量

2012-03-17T15:33:00Z

今天整理“信号量”的相关知识，其实想想也蛮有趣的，锁，互斥，信号量都可以实现线程同步，在framework里面主要有三种。

<1>：ManualResetEvent

<2>：AutoResetEvent

<3>: Semaphore

好，下面就具体看看这些玩意的使用。

一：ManualResetEvent

该对象有两种信号量状态True和False，好奇的我们肯定想知道True和False有什么区别，稍后的例子见分晓，有三个方法值得学习一下。

1：WaitOne

该方法用于阻塞线程，默认是无限期的阻塞，有时我们并不想这样，而是采取超时阻塞的方法，如果超时就放弃阻塞，这样也就避免了无限期

等待的尴尬。

2：Set

手动修改信号量为True，也就是恢复线程执行。

3:ReSet

手动修改信号量为False，暂停线程执行。

好了，下面举个例子说明一下。

<1> 信号量初始为False，WaitOne采用无限期阻塞，可以发现线程间可以进行交互。

1 public class Example
2 {
3 public static void Main()
4 {
5 Thread t = new Thread(Run);
6
7 t.Name = "Jack";
8
9 Console.WriteLine("当前时间:{0} {1} {1},我是主线程,收到请回答。", DateTime.Now, t.Name);
10
11 t.Start();
12
13 Thread.Sleep(5000);
14
15 mr.Set();
16
17 Console.Read();
18 }
19
20 static ManualResetEvent mr = new ManualResetEvent(false);
21
22 static void Run()
23 {
24 mr.WaitOne();
25
26 Console.WriteLine("\n当前时间:{0} 主线程，主线程,{1}已收到！", DateTime.Now, Thread.CurrentThread.Name);
27 }
28 }

<2> 信号量初始为True，WaitOne采用无限期阻塞，实验发现WaitOne其实并没有被阻塞。

static ManualResetEvent mr = new ManualResetEvent(true);

<3>信号量初始为False，WaitOne采用超时2s，虽然主线程要等5s才能进行Set操作，但是WaitOne已经等不及提前执行了。

1 public class Example
2 {
3 public static void Main()
4 {
5 Thread t = new Thread(Run);
6
7 t.Name = "Jack";
8
9 Console.WriteLine("当前时间:{0} {1} {1},我是主线程,收到请回答。", DateTime.Now, t.Name);
10
11 t.Start();
12
13 Thread.Sleep(5000);
14
15 mr.Set();
16
17 Console.Read();
18 }
19
20 static ManualResetEvent mr = new ManualResetEvent(false);
21
22 static void Run()
23 {
24 mr.WaitOne(2000);
25
26 Console.WriteLine("\n当前时间:{0} 主线程，主线程,{1}已收到！", DateTime.Now, Thread.CurrentThread.Name);
27 }
28 }

二：AutoResetEvent

在VS对象浏览器中，我们发现AutoResetEvent和ManualResetEvent都是继承于EventWaitHandle，所以基本功能是一样的，不过值得注意

的一个区别是WaitOne会改变信号量的值，比如说初始信号量为True，如果WaitOne超时信号量将自动变为False，而ManualResetEvent则不会。

1 public class Example
2 {
3 public static void Main()
4 {
5 Thread t = new Thread(Run);
6
7 t.Name = "Jack";
8
9 t.Start();
10
11 Console.Read();
12 }
13
14 static AutoResetEvent ar = new AutoResetEvent(true);
15
16 static void Run()
17 {
18 var state = ar.WaitOne(1000, true);
19
20 Console.WriteLine("我当前的信号量状态:{0}", state);
21
22 state = ar.WaitOne(1000, true);
23
24 Console.WriteLine("我恨你，不理我，您现在的状态是:{0}", state);
25
26 }
27 }

三：Semaphore

这玩意是.net 4.0新增的，用于控制线程的访问数量，默认的构造函数为initialCount和maximumCount，表示默认设置的信号量个数和

最大信号量个数，其实说到底，里面是采用计数器来来分配信号量，当你WaitOne的时候，信号量自减，当Release的时候，信号量自增，然而

当信号量为0的时候，后续的线程就不能拿到WaitOne了，所以必须等待先前的线程通过Release来释放。

好了，下面还是举例子来说明一下：

<1> initialCount=1,maximunCount=10,WaitOne采用无限期等待。

1 namespace ConsoleApplication3
2 {
3 class Program
4 {
5 static void Main(string[] args)
6 {
7
8 Thread t1 = new Thread(Run1);
9 t1.Start();
10
11 Thread t2 = new Thread(Run2);
12 t2.Start();
13
14 Console.Read();
15 }
16
17 static Semaphore sem = new Semaphore(1, 10);
18
19 static void Run1()
20 {
21 sem.WaitOne();
22
23 Console.WriteLine("大家好，我是Run1");
24 }
25
26 static void Run2()
27 {
28 sem.WaitOne();
29
30 Console.WriteLine("大家好，我是Run2");
31 }
32 }
33 }

我们悲剧的发现t2线程不能执行，我们知道WaitOne相当于自减信号量，然而默认的信号量个数为1，所以t2想执行必须等待t1通过Release来释放。

1 static void Run1()
2 {
3 sem.WaitOne();
4
5 Console.WriteLine("大家好，我是Run1");
6
7 sem.Release();
8 }

可能有的同学要问，我不是设置了maximunCount=10吗？为什么没有起到作用？是的，默认情况下是没有起到作用，必须要我们手动干预一下，

我们知道调用Release方法相当于自增一个信号量，然而Release有一个重载，可以指定自增到maximunCount个信号量，这里我就在主线程上

Release(10),看看效果。

1 namespace ConsoleApplication3
2 {
3 class Program
4 {
5 static void Main(string[] args)
6 {
7
8 Thread t1 = new Thread(Run1);
9 t1.Start();
10
11 Thread t2 = new Thread(Run2);
12 t2.Start();
13
14 Thread.Sleep(1000);
15
16 sem.Release(10);
17
18 Console.Read();
19 }
20
21 static Semaphore sem = new Semaphore(1, 10);
22
23 static void Run1()
24 {
25 sem.WaitOne();
26
27 Console.WriteLine("大家好，我是Run1");
28 }
29
30 static void Run2()
31 {
32 sem.WaitOne();
33
34 Console.WriteLine("大家好，我是Run2");
35 }
36 }
37 }

<2> Semaphore命名，升级进程交互。

在VS对象浏览器中发现Semaphore是继承字WaitHandle，而WaitHandle封装了win32的一些同步机制，所以当我们给Semaphore命名的时候

就会在系统中可见，下面举个例子，把下面的代码copy一份，运行两个程序。

1 namespace ConsoleApplication3
2 {
3 class Program
4 {
5 static void Main(string[] args)
6 {
7
8 Thread t1 = new Thread(Run1);
9 t1.Start();
10
11 Thread t2 = new Thread(Run2);
12 t2.Start();
13
14 Console.Read();
15 }
16
17 static Semaphore sem = new Semaphore(3, 10, "cnblogs");
18
19 static void Run1()
20 {
21 sem.WaitOne();
22
23 Console.WriteLine("当前时间:{0} 大家好，我是Run1", DateTime.Now);
24 }
25
26 static void Run2()
27 {
28 sem.WaitOne();
29
30 Console.WriteLine("当前时间:{0} 大家好，我是Run2", DateTime.Now);
31 }
32 }
33 }

是的，我设置了信号量是3个，所以只能有三个线程持有WaitOne，后续的线程只能苦苦的等待。

本文链接

博客园_一线码农

8天玩转并行开发——第六天 异步编程模型

12篇学通C#网络编程——第三篇 HTTP应用编程（下）

lucene，你也会(7篇）——第一篇 快速入门

8天玩转并行开发——第五天 同步机制（下）

8天玩转并行开发——第四天 同步机制（上）

8天玩转并行开发——第三天 plinq的使用

8天玩转并行开发——第二天 Task的使用

8天玩转并行开发——第一天 Parallel的使用

5天不再惧怕多线程——第五天 线程池

5天不再惧怕多线程——第四天 信号量

8天玩转并行开发——第六天异步编程模型

lucene，你也会(7篇）——第一篇快速入门

8天玩转并行开发——第五天同步机制（下）

8天玩转并行开发——第四天同步机制（上）

5天不再惧怕多线程——第五天线程池

5天不再惧怕多线程——第四天信号量