厚积薄发，丰富的公用类库积累，助你高效进行系统开发（10）---各种线程同步的集合类

俗话说，一个好汉十个帮，众人拾柴火焰高等都说明一个道理，有更多的资源，更丰富的积累，都是助你走向成功，走向顶峰的推动力。

本篇的公用类库的介绍主题是程序开发中多线程操作环境中，常用到的线程安全的各类同步集合、字典等对象，这些辅助类通过封装及继承关系，获得更加丰富完善的集合类，并且增加了线程锁，实现多线程访问的集合类。本篇随笔介绍包含有有序字典集合、同步字典集合、有序同步字典集合、同步列表、同步先进先出队列等对象。

本篇继续继续整理优化已有的共用类库，并继续发表随笔介绍公用类库的接口方法以及详细使用操作，力求给自己继续优化，积攒更丰富的公用类库资源，加深了解的同时，也给大家展现公用类库好的方面。
**1、有序的字典集合 OrderedDictionary。 **
实现效果

本辅助类主要是用来方便实现有序的字典集合操作。一个有序的字典是一个集合类，它里面的项目可以通过其索引或他们的键进行操作。。 2) 有序集合对象，特点是查找非常高效率，并且提供了强类型的数据操作，不过由于其需要额外在列表中存储数据，因此尽量减少插入或者删除集合对象。 3) 有序的字典集合，虽然存在一些缺点，但是提供了一个非常灵活和用户友好数据结构，允许通过键值或索引进行访问。
实现代码
1）辅助类提供的方法接口如下所示：

/// <summary>    
/// 判断字典<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see> 是否包含指定的值。    
/// </summary>    
/// <param name="value">待判断的值,如果值为引用类型，则可以为null</param>    
/// <returns>    
/// 如果字典包含项目，则返回true，否则为false。    
/// </returns>
public virtual bool ContainsValue(TValue value)    
   
/// <summary>    
/// 判断字典是否包含指定键的元素    
/// </summary>    
/// <param name="key">在字典中查找的键.</param>    
/// <returns>    
/// 如果字典中包含指定键的元素，返回true，否则为false    
/// </returns>    
/// <exception cref="System.ArgumentNullException">键为空</exception>
public virtual bool ContainsKey(TKey key)            
   
/// <summary>    
/// 在字典中添加一个元素，根据提供的键和值    
/// </summary>    
/// <param name="key">作为待添加元素的键</param>    
/// <param name="value">作为待添加元素的值.</param>    
/// <exception cref="System.NotSupportedException">字典对象为只读</exception>    
/// <exception cref="System.ArgumentException">含有相同键的元素已经存在字典中</exception>    
/// <exception cref="System.ArgumentNullException">键为空.</exception>
public virtual void Add(TKey key, TValue value)            
   
/// <summary>    
/// 在指定的索引插入元素    
/// </summary>    
/// <param name="index">插入位置，从零开始的索引</param>    
/// <param name="key">作为待插入元素的键</param>    
/// <param name="value">作为待插入元素的值</param>    
/// <exception cref="T:System.NotSupportedException">集合为只读</exception>    
/// <exception cref="T:System.ArgumentOutOfRangeException">指定索引在<see cref="T:System.Collections.Generic.IList`1"></see>中为无效索引.</exception>
public void Insert(int index, TKey key, TValue value)            
   
/// <summary>    
/// 获取指定键的元素索引    
/// </summary>    
/// <param name="key">待查找的键</param>    
/// <returns>    
/// 如果列表中发现则为项目的索引，否则为-1。    
/// </returns>
public int IndexOf(TKey key)                    
   
/// <summary>    
/// 获取指定键的元素索引    
/// </summary>    
/// <param name="value">待查找的键</param>    
/// <returns>    
/// 如果列表中发现则为项目的索引，否则为-1。    
/// </returns>
public int IndexOf(TValue value)           
   
/// <summary>    
/// 获取或设置与指定键的值。    
/// </summary>
public virtual TValue this[TKey key]            
   
/// <summary>获取或设置指定索引相关联的值</summary>    
/// <returns>返回指定索引中关联的值, 如果指定的索引为无效，获取或设置操作将抛出 <see cref="ArgumentOutOfRangeException"></see>。    
/// </returns>    
/// <param name="index">获取或设置值的索引</param>    
/// <exception cref="ArgumentOutOfRangeException">索引大于集合数量或者小于0</exception>
public virtual TValue this[int index]                    
   
/// <summary>    
/// 复制集合元素到数组中, 以数组的索引开始.    
/// </summary>    
/// <param name="array">一维数组<see cref="System.Array"></see>，它是从集合中复制的目标。数组对象必须是从零开始的索引。</param>    
/// <param name="arrayIndex">Array中的从零开始的索引，位于复制开始。</param>    
/// <exception cref="System.ArgumentOutOfRangeException">arrayIndex 小于0</exception>    
/// <exception cref="System.ArgumentNullException">array 为null</exception>    
/// <exception cref="System.ArgumentException">    
/// 数组为多维；或arrayIndex等于或大于数组的长度；    
/// 或源集合中元素的数量大于arrayIndex到目标数组结束间可用空间。    
/// 或者TKey的类型不能自动转换为目标数组的类型。</exception>
public virtual void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)            
        
/// <summary>    
/// 创建一个新的对象，它是当前实例的一个副本    
/// </summary>    
/// <returns>    
/// 一个新的对象，此实例的一个副本。    
/// </returns>
public OrderedDictionary<TKey, TValue> Clone()

2）辅助类OrderedDictionary的使用例子代码如下所示，由于OrderedDictionary在检索的时候效率很高，而且可以通过索引和键进行定位，提供了较好的操作性和方便性。输出结果如下所示，我们看到，他们虽然可以通过键和索引进行访问，但是他们的顺序不会发生变化。

OrderedDictionary<string, string> syncDict = new OrderedDictionary<string, string>();    
syncDict.Add("A", "testA");    
syncDict.Add("C", "testC");    
syncDict.Add("B", "TestB");    
   
//通过键访问    
StringBuilder sb = new StringBuilder();    
foreach (string key in syncDict.Keys)    
{    
    sb.AppendFormat("{0}:{1}\r\n", key, syncDict[key]);    
}    
sb.AppendLine();    
   
//通过索引访问    
for (int i = 0; i < syncDict.Keys.Count; i++)    
{    
    sb.AppendFormat("{0}:{1}\r\n", i, syncDict[i]);    
}    
MessageUtil.ShowTips(sb.ToString());

辅助类OrderedDictionary和.NET框架内置SortedDictionary不同，他虽然都支持泛型类型，不过键和索引方式访问，后者只是对键进行排序的字典类，并未提供以索引方式进行取值的。

//框架内置的排序字典    
SortedDictionary<string, string> sortDict = new SortedDictionary<string, string>();    
sortDict.Add("A", "testA");    
sortDict.Add("C", "testC");    
sortDict.Add("B", "TestB");    
   
sb = new StringBuilder();    
foreach (string key in sortDict.Keys)    
{    
    sb.AppendFormat("{0}:{1}\r\n", key, sortDict[key]);    
}    
MessageUtil.ShowTips(sb.ToString());

而SortedDictionary例子的输出结果如下所示，从中我们可以看到，遍历键的时候，它们已经经过了字母从大到小进行排序了。

**2、同步的字典集合 SyncDictionary。 **
实现效果

现同步的字典集合操作。一个同步的字典提供一个线程安全的字典集合。 2) 同步字典对象，提供了多线程之间线程安全的访问机制，使你不必担心发送多线程之间的添加、移除、访问等的冲突，放心使用。 3) SyncDictionary类继承了CDictionary类,CDictionary继承了框架的Dictionary类，CDictionary并实现了一些克隆及序列化的接口。SyncDictionary类具有Dictionary类的一切特点，另外他还具备线程安全的特点。

实现代码
1）辅助类提供的方法接口如下所示：

/// <summary>    
/// 获取指定键的关联值    
/// </summary>    
/// <param name="key">字典键</param>    
/// <param name="value">当此方法返回值时，如果找到该键，便会返回与指定的键相关联的值；否则，则会返回 value 参数的类型默认值。该参数未经初始化即被传递。</param>    
/// <returns>如果字典对象包含具有指定键的元素，则为 true；否则为false. </returns>
public new bool TryGetValue(TKey key, out TValue value)    
   
/// <summary>获取或设置指定键的值</summary>    
/// <returns>与指定键关联的值。如果没有找到指定键，KeyNotFoundException将抛出，操作创建一个有指定键的新元素。</returns>    
/// <param name="key">设定值的键</param>    
/// <exception cref="System.ArgumentNullException">键位空</exception>    
/// <exception cref="System.Collections.Generic.KeyNotFoundException">属性检索和键在集合不存在。</exception>
public new TValue this[TKey key]    
   
/// <summary>获取字典对象的键集合</summary>
public new KeyCollection Keys    
   
/// <summary>获取字典中值的对象集合</summary>
public new ValueCollection Values    
   
/// <summary>获取<see cref="System.Collections.Generic.IEqualityComparer{TKey}"></see> 对象，该对象用来比较字典表键的相等</summary>    
/// <returns>对象<see cref="System.Collections.Generic.IEqualityComparer{TKey}"></see> 通用接口，用来判断当前对象<see cref="T:System.Collections.Generic.Dictionary`2"></see>的相等性，    
/// 并提供键的哈希值.</returns>
public new IEqualityComparer<TKey> Comparer    
   
/// <summary>    
/// 获取字典集合中包含键值对的数量    
/// </summary>    
/// <value></value>    
/// <returns>字典集合中所含元素的数目</returns>
public new virtual int Count    
   
/// <summary>在集合中移除指定键的元素</summary>    
/// <returns>如果元素被移除返回true，否则为false。如果原始集合中没有发现指定键的元素，也返回false。</returns>    
/// <param name="key">待移除元素的键</param>    
/// <exception cref="System.ArgumentNullException">键为空</exception>
public new bool Remove(TKey key)    
   
/// <summary>获取迭代结合的枚举器.</summary>
public new Enumerator GetEnumerator()    
   
/// <summary>    
/// 初始化SyncDictionary对象实例    
/// </summary>    
/// <param name="dictionary">字典对象</param>
public SyncDictionary(CDictionary<TKey, TValue> dictionary)    
   
/// <summary>    
/// 初始化SyncDictionary对象实例    
/// </summary>
public SyncDictionary()    
   
/// <summary>    
/// 为字典表添加指定的键值    
/// </summary>    
/// <param name="key">待添加元素的键</param>    
/// <param name="value">待添加元素的值. 该值可以是空引用类型.</param>    
/// <exception cref="System.ArgumentException">一个具有相同键的元素已经存在于字典</exception>    
/// <exception cref="System.ArgumentNullException">键为空</exception>
public new void Add(TKey key, TValue value)    
   
/// <summary>    
/// 获取一个值，指出对集合的存取是否同步（线程安全）    
/// </summary>    
/// <value>如果词典的访问是同步的（线程安全）则为True，否则为false。默认为false。 </value>
public override bool IsSynchronized    
   
/// <summary>    
/// 从字典中移除所有的键值    
/// </summary>
public new void Clear()    
   
/// <summary>    
/// 实现 <see cref="System.Runtime.Serialization"></see> 接口并返回需要序列化字典<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see> 实例的数据。    
/// </summary>    
/// <param name="info">一个 SerializationInfo 对象，它包含序列化Dictionary所需的信息。</param>    
/// <param name="context"> StreamingContext 结构，该结构包含与 Dictionary相关联的序列化流的源和目标。</param>    
/// <exception cref="System.ArgumentNullException">info为空引用</exception>
[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]    
public override void GetObjectData(SerializationInfo info, StreamingContext context)    
   
/// <summary>    
/// 初始化SyncDictionary对象实例    
/// </summary>    
/// <param name="info"><see cref="System.Runtime.Serialization.SerializationInfo"></see>对象包含序列化<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>的必要信息。</param>    
/// <param name="context">A <see cref="System.Runtime.Serialization.StreamingContext"></see> 含有与序列化流<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>的源和目标的结构。</param>
internal SyncDictionary(SerializationInfo info, StreamingContext context): base(info, context)    
   
/// <summary>    
/// 把ICollection的元素复制到一个KeyValuePair类型的数组，在指定的阵列索引开始。    
/// </summary>    
/// <param name="array">一维数组类型KeyValuePair是从ICollection复制KeyValuePair元素的目标。该数组必须具有从零开始的索引。</param>    
/// <param name="index">array中的从零开始的索引，位于复制开始</param>
public new void CopyTo(KeyValuePair<TKey, TValue>[] array, int index)    
   
/// <summary>    
/// 实现 <see cref="System.Runtime.Serialization.ISerializable"></see> 接口并抛出反序列化事件，当反序列化完成的时候。    
/// </summary>    
/// <param name="sender">反序列化事件的源对象</param>    
/// <exception cref="T:System.Runtime.Serialization.SerializationException">在当前字典中关联的该对象为无效对象.</exception>
public override void OnDeserialization(object sender)    
   
/// <summary>    
/// 确定指定的键是否包含关键。    
/// </summary>    
/// <param name="key">键</param>    
/// <returns>    
///     如果包含指定的键返回True，否则false。    
/// </returns>
public new bool ContainsKey(TKey key)    
   
/// <summary>    
/// 判断<see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see>是否包含指定的值    
/// </summary>    
/// <param name="value">在字典中待查找的值，如果值是引用类型则可以为null。</param>    
/// <returns>    
/// 如果 <see cref="System.Collections.Generic.Dictionary{TKey, TValue}"></see> 包含指定值的元素返回true，否则返回false.    
/// </returns>
public new bool ContainsValue(TValue value)

2）本辅助类主要是用来方便实辅助类SyncDictionary的使用例子代码如下所示，由于SyncDictionary线程安全，非常适合在多线程的环境下进行操作，如Socket服务器处理、后台线程数据处理等环境下。

SyncDictionary<string, string> syncDict = new SyncDictionary<string, string>();    
syncDict.Add("A", "testA");    
syncDict.Add("C", "testC");    
syncDict.Add("B", "TestB");    
   
//通过键访问    
StringBuilder sb = new StringBuilder();    
foreach (string key in syncDict.Keys)    
{    
    sb.AppendFormat("{0}:{1}\r\n", key, syncDict[key]);    
}    
sb.AppendLine();       
MessageUtil.ShowTips(sb.ToString());

输出结果如下所示，我们看到，他们虽然可以通过键和索引进行访问，但是他们的顺序不会发生变化。

另外它的线程安全，使得其多线程之间的操作也是非常安全、高效的。

SyncDictionary<string, string> syncDict = new SyncDictionary<string, string>();    
private void btnSyncTest_Click(object sender, EventArgs e)    
{    
    for (int i = 0; i < 5; i++)    
    {    
        Thread thread = new Thread(new ThreadStart(AddSyncDict));    
        thread.Start();    
        thread.Join();//等待线程完成才返回主线程    
    }    
   
    StringBuilder sb = new StringBuilder();    
    foreach (string key in syncDict.Keys)    
    {    
        sb.AppendFormat("Key:{0}   Value:{1} \r\n", key, syncDict[key]);    
    }    
    MessageUtil.ShowTips(sb.ToString());    
}    
   
private void AddSyncDict()    
{    
    string key = new Random().Next().ToString();    
    if (!syncDict.ContainsKey(key))    
    {    
        syncDict.Add(key, DateTime.Now.ToString());    
    }    
    Thread.Sleep(100);    
}

多线程之间操作的运行效果如下所示

**3、同步、有序的字典集合 SyncOrderedDictionary。 **
实现效果
1）本辅助类主要是用来方便实现同步、有序的字典集合操作。一个同步的字典提供一个线程安全的字典集合；一个有序的字典是一个集合类，它里面的项目可以通过其索引或他们的键进行操作。。 2）同步字典对象，提供了多线程之间线程安全的访问机制，使你不必担心发送多线程之间的添加、移除、访问等的冲突，放心使用。 3）有序集合对象，特点是查找非常高效率，并且提供了强类型的数据操作，不过由于其需要额外在列表中存储数据，因此尽量减少插入或者删除集合对象。 4）有序的字典集合，虽然存在一些缺点，但是提供了一个非常灵活和用户友好数据结构，允许通过键值或索引进行访问。 5） SyncOrderedDictionary类继承了OrderedDictionary类，具有OrderedDictionary类的一切特点，另外他还具备线程安全的特点。

实现代码
1）辅助类提供的方法接口如下所示：
接口综合了以上两种（同步、有序）字典类的特点，接口代码不在粘贴出来。

2）辅助类SyncOrderedDictionary的使用例子代码如下所示，由于SyncOrderedDictionary在检索的时候效率很高，而且可以通过索引和键进行定位，提供了较好的操作性和方便性。另外由于线程安全，非常适合在多线程的环境下进行操作，如Socket服务器处理、后台线程数据处理等环境下。

SyncOrderedDictionary<string, string> syncDict = new SyncOrderedDictionary<string, string>();    
syncDict.Add("A", "testA");    
syncDict.Add("C", "testC");    
syncDict.Add("B", "TestB");    
   
//通过键访问    
StringBuilder sb = new StringBuilder();    
foreach (string key in syncDict.Keys)    
{    
    sb.AppendFormat("{0}:{1}\r\n", key, syncDict[key]);    
}    
sb.AppendLine();    
   
//通过索引访问    
for (int i = 0; i < syncDict.Keys.Count; i++)    
{    
    sb.AppendFormat("{0}:{1}\r\n", i, syncDict[i]);    
}    
MessageUtil.ShowTips(sb.ToString());

输出结果如下所示，我们看到，他们虽然可以通过键和索引进行访问，但是他们的顺序不会发生变化。

**4、同步的列表集合 SyncList。 **
实现效果
1）本辅助类主要是用来方便实现同步列表集合操作。一个同步的列表集合提供一个线程安全的列表集合； 2）同步字典对象，提供了多线程之间线程安全的访问机制，使你不必担心发送多线程之间的添加、移除、访问等的冲突，放心使用。

实现代码
1）辅助类提供的方法接口如下所示，该类继承一个自定义的CList，CList实现了克隆等一些接口，SyncList的函数接口定义如下：

/// <summary>    
/// 初始化一个同步列表对象实例    
/// </summary>
public SyncList()    
        
/// <summary>    
/// 初始化一个同步列表对象实例    
/// </summary>    
/// <param name="list">The list.</param>
public SyncList(CList<T> list)    
   
/// <summary>    
/// 获取一个值，判断<see cref="System.Collections.ICollection"></see> 是否为同步的（线程安全）.    
/// </summary>    
/// <value>如果为同步（线程安全）的，返回true,否则false. 默认为false </value>    
/// <returns>如果为同步（线程安全）的，返回true,否则false</returns>
public override bool IsSynchronized    
   
/// <summary>添加一个对象到 <see cref="System.Collections.Generic.List<T>"></see>末尾.</summary>    
/// <param name="item">待添加的对象. 值可以为空引用类型。</param>
public new void Add(T item)    
   
/// <summary>添加一个集合到 <see cref="System.Collections.Generic.List<T>"></see>末尾</summary>    
/// <param name="collection">其集合元素待添加到 <see cref="System.Collections.Generic.List<T>"></see>末尾的集合.     
/// 集合本身不能为空，但如果类型TKey是一个引用类型，则它包含的元素可以为空</param>    
/// <exception cref="System.ArgumentNullException">集合为空</exception>
public new void AddRange(IEnumerable<T> collection)    
   
/// <summary>    
/// 为当前集合返回一个只读的<see cref="System.Collections.Generic.IList<T>"></see> 包装类。    
/// </summary>
public new ReadOnlyCollection<T> AsReadOnly()    
   
/// <summary>    
/// 从<see cref="System.Collections.Generic.List<T>"></see>集合中移除所有对象。    
/// </summary>
public new void Clear()    
   
/// <summary>判定指定的元素是否在 <see cref="System.Collections.Generic.List<T>"></see> 中.</summary>    
/// <returns>如果元素在 <see cref="System.Collections.Generic.List<T>"></see>中存在返回true，否则返回false.</returns>    
/// <param name="item">待查找的元素，如果值为引用类型则可以为null</param>
public new bool Contains(T item)    
   
/// <summary>    
/// 转换当前 <see cref="System.Collections.Generic.List<T>"></see> 的元素到另外的类型，并返回包含转换后的元素列表。    
/// </summary>    
/// <returns>一个<see cref="System.Collections.Generic.List<T>"></see>集合，包含当前集合转换后的元素。</returns>    
/// <param name="converter">每个元素从一种类型到另一种类型的转换委托</param>    
/// <exception cref="System.ArgumentNullException">converter 为 null.</exception>
public new CList<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter)    
   
/// <summary>复制整个 <see cref="System.Collections.Generic.List<T>"></see> 到一个一维数组中</summary>    
/// <param name="array">一维数组，从列表中复制元素的目标对象。该数组必须具有从零开始的索引。</param>    
/// <exception cref="System.ArgumentException">源列表中元素的数量大于目标数组能容纳的数量</exception>    
/// <exception cref="System.ArgumentNullException">array 为 null.</exception>
public new void CopyTo(T[] array)    
   
/// <summary>复制整个 <see cref="System.Collections.Generic.List<T>"></see> 到一个一维数组中</summary>    
/// <param name="array">一维数组，从列表中复制元素的目标对象。该数组必须具有从零开始的索引。</param>    
/// <param name="arrayIndex">array中的从零开始的索引，位于复制开始。</param>    
/// <exception cref="System.ArgumentException">arrayIndex 大于或等于array数组长度；或源列表的元素数量大于目标array数组从arrayIndex到结束的可用空间</exception>    
/// <exception cref="System.ArgumentOutOfRangeException">arrayIndex 小于等于 0.</exception>    
/// <exception cref="System.ArgumentNullException">array 为 null.</exception>
public new void CopyTo(T[] array, int arrayIndex)    
   
/// <summary>    
/// 从列表中复制一个范围内的元素到一个相容的一维数组中。以指定的目标索引开始。    
/// </summary>    
/// <param name="index">在从零开始的索引，位于复制开始的源。</param>    
/// <param name="array">一维数组，从列表中复制元素的目标对象。该数组必须具有从零开始的索引。</param>    
/// <param name="arrayIndex">array中的从零开始的索引，位于复制开始。</param>    
/// <param name="count">待复制的元素数量.</param>    
/// <exception cref="System.ArgumentNullException">array 为 null. </exception>    
/// <exception cref="System.ArgumentOutOfRangeException">index 小于 0；或者arrayIndex 小于0；或者count 小于 0. </exception>    
/// <exception cref="System.ArgumentException">index 大于或等于源列表的数量。或者arrayIndex 大于或等于数组array的长度。或者从index到源列表结束的元素数量大于从 arrayIndex 到数组array结束的可用空间。 </exception>
public new void CopyTo(int index, T[] array, int arrayIndex, int count)    
   
/// <summary>    
/// 判定<see cref="System.Collections.Generic.List<T>"></see>是否包含符合定义在指定predicate的条件中包含有元素。</summary>    
/// <returns>如果列表中包含指定条件的元素，返回true，否则为false。</returns>    
/// <param name="match">定义元素的条件来搜索对象的委托</param>    
/// <exception cref="System.ArgumentNullException">match 为 null.</exception>
public new bool Exists(Predicate<T> match)    
   
/// <summary>根据定义条件查询一个元素，并返回第一个在整个列表中出现的元素.</summary>    
/// <returns>根据查询条件，第一个在整个列表中出现的元素，如果没有找到，返回Tkey类型的默认值。</returns>    
/// <param name="match">定义元素的条件来搜索的委托</param>    
/// <exception cref="System.ArgumentNullException">match 为 null.</exception>
public new T Find(Predicate<T> match)    
   
/// <summary>获取指定Predicate定义的条件相匹配的所有元素。</summary>    
/// <returns>如果遭到元素，返回指定Predicate定义的条件相匹配的所有元素列表，否则返回一个空列表。</see>.</returns>    
/// <param name="match">定义元素的条件来搜索的委托</param>    
/// <exception cref="System.ArgumentNullException">match 为 null.</exception>
public new CList<T> FindAll(Predicate<T> match)    
。。。。。。。。。。。。。。。。。

2）辅助类SyncList的使用例子代码如下所示，由于线程安全，非常适合在多线程的环境下进行操作，如Socket服务器处理、后台线程数据处理等环境下。

SyncList<string> syncList = new SyncList<string>();    
private void btnSyncTest_Click(object sender, EventArgs e)    
{    
    for (int i = 0; i < 5; i++)    
    {    
        Thread thread = new Thread(new ThreadStart(AddSyncList));    
        thread.Start();    
        thread.Join();//等待线程完成才返回主线程    
    }    
   
    StringBuilder sb = new StringBuilder();    
    foreach (string item in syncList)    
    {    
        sb.AppendFormat("item:{0} \r\n", item);    
    }    
    MessageUtil.ShowTips(sb.ToString());    
}    
   
private void AddSyncList()    
{    
    string key = new Random().Next().ToString();    
    syncList.Add(key);    
    Thread.Sleep(100);    
}

输出结果如下所示。

**5、线程安全的先进先出队列辅助类 Fifo。 **
实现效果
1）本辅助类主要是用来方便实现线程安全的先进先出队列操作。 2）线程安全的先进先出队列，提供了多线程之间线程安全的访问机制，使你不必担心发送多线程之间的进队、出队等的冲突，放心使用。 3）Fifo类组合了先进先出的Queue类，提供了线程安全的操作，称为队列或环形缓冲区，这是一种采用先进先出结构（FIFO）的数据结构。现实生活中这种结构应用得非常广泛。比如某些公司的货仓管理系统，要求将先生产的货物先出货，后生产的货物后出货。另外一种场景就是Socket数据包处理的时候，我们一般是把他放到Fifo队列里面，实现先进先出的合理处理。

实现代码
1）辅助类提供的方法接口如下所示：

/// <summary>    
/// 队列中目前存在个数    
/// </summary>
public int Count    
   
/// <summary>    
/// 队列的最大容量    
/// </summary>
public int MaxCount    
   
/// <summary>    
/// 重新设置队列的最大容量    
/// </summary>    
/// <param name="MaxCount">大于1的整数</param>
public void ResetMaxCount(int MaxCount)    
   
/// <summary>    
/// 元素进队， 将指定的对象值添加到队列的尾部    
/// </summary>    
/// <param name="obj">T 型的参数</param>
public void Append(T obj)    
   
/// <summary>    
/// 元素出队，即移除队列中开始的元素，按先进先出（FIFO）的规则，从前向后移除元素。    
/// </summary>    
/// <returns></returns>
public T Pop()

2）辅助类Fifo的使用例子代码如下所示，由于Fifo线程安全，非常适合在多线程的环境下进行操作，如Socket服务器处理、后台线程数据处理等环境下。

/// <summary>    
/// 组包后数据的队列（先进先出）    
/// </summary>
protected Fifo<PreData> _preDataFifo = new Fifo<PreData>(50000);    
   
/// <summary>    
/// 接收处理数据    
/// </summary>    
/// <param name="data">包体</param>
public void AppendPreData(PreData data)    
{    
    this._preDataFifo.Append(data);    
}           

/// <summary>    
/// 数据处理    
/// </summary>
protected virtual void PreDataHandle()    
{    
    try   
    {    
        while (true)    
        {    
            PreData data = _preDataFifo.Pop();    
            if (data != null)    
            {    
                PreDataHandle(data);    
            }    
        }    
    }    
    catch(Exception ex)    
    {    
        string message = string.Format("[{0}.PreDataHandle]  desc:接收器处理异常->{1}", this._Name, ex.ToString());    
        Log.WriteError(message, ex.ToString(), true);    
    }    
}    
   
/// <summary>    
/// 对每一个包体的数据进行处理    
/// </summary>    
/// <param name="data">包体</param>
public virtual void PreDataHandle(PreData data)    
{     
}

**6、各种常用数组排序操作辅助类 SortHelper****。 **
实现效果
1）本辅助类主要是用来方便实现各种常用数组排序操作，包括冒泡排序法、插入排序法、选择排序法、希尔排序法、快速排序法。
2）本辅助类提供一些常用的排序操作，也可以作为学习排序的基础教程。

实现代码
1）辅助类提供的方法接口如下所示：

/// <summary>    
/// 冒泡排序法 
/// </summary>    
/// <param name="list">待排序数组</param>
public static void BubbleSort(int[] list)    
   
/// <summary>    
/// 插入排序法    
/// </summary>    
/// <param name="list">待排序数组</param>
public static void InsertionSort(int[] list)    
   
/// <summary>    
/// 选择排序法    
/// </summary>    
/// <param name="list">待排序数组</param>
public static void SelectionSort(int[] list)    
   
/// <summary>    
/// 希尔排序法    
/// </summary>    
/// <param name="list">待排序数组</param>
public static void ShellSort(int[] list)    
   
/// <summary>    
/// 快速排序法    
/// </summary>    
/// <param name="list">待排序数组</param>    
/// <param name="low">低位</param>    
/// <param name="high">高位</param>
public static void QuickSort(int[] list, int low, int high)

2）辅助类SortHelper的使用例子代码如下所示。

private void btnSort_Click(object sender, EventArgs e)    
{    
    //冒泡排序法    
    int[] list = new int[10] { 0, 1, 2, 3, 4, 9, 8, 7, 6, 5 };    
    SortHelper.BubbleSort(list);    
    StringBuilder sb = new StringBuilder();    
    foreach (int i in list)    
    {    
        sb.AppendFormat("{0},", i);    
    }    
    MessageUtil.ShowTips(sb.ToString());    
   
    //插入排序法    
    list = new int[10] { 0, 1, 2, 3, 4, 9, 8, 7, 6, 5 };    
    SortHelper.InsertionSort(list);    
    sb = new StringBuilder();    
    foreach (int i in list)    
    {    
        sb.AppendFormat("{0},", i);    
    }    
    MessageUtil.ShowTips(sb.ToString());    
}

其他的接口排序差不多也是如此调用和结果的，只是在排序效率上有所差异。

最后编辑于：2017.12.04 01:15:41

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 199,830评论 5赞 468
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 83,992评论 2赞 376
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 146,875评论 0赞 331
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 53,837评论 1赞 271
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 62,734评论 5赞 360
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,091评论 1赞 277
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,550评论 3赞 390
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,217评论 0赞 254
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,368评论 1赞 294
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,298评论 2赞 317
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,350评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,027评论 3赞 315
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,623评论 3赞 303
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,706评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,940评论 1赞 255
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,349评论 2赞 346
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 41,936评论 2赞 341

厚积薄发，丰富的公用类库积累，助你高效进行系统开发（10）---各种线程同步的集合类

推荐阅读更多精彩内容