一,集合之线程同步

即位于System.Collections命名空间下的集合,如Hashtable,ArrayList,Stack,Queue等.其均提供了线程同步的一个实现

每种数据类型都包含一个静态的Synchronized方法,如

方法1，

并发读一个写。如果有多个线程并发的企图写list里面的 item, 则同一时刻只能有一个线程写, 其余阻塞; 对读的线程则不受影响。

ArrayList list = ArrayList.Synchronized(new ArrayList(1000000));
方法2，自己加控制锁 

public class Demo8
{
    ArrayList list = new ArrayList(1000000);
    public Demo8()
    {
        ThreadPool.QueueUserWorkItem(new WaitCallback(Task1));
        ThreadPool.QueueUserWorkItem(new WaitCallback(Task2));
    }

    public void Task1(object obj)
    {
        lock (list.SyncRoot)
        {
            for (int i = 0; i < 500000; i++)
            {
                list.Add(i);
            }
        } 
       
        Console.WriteLine(DateTime.Now);
        Console.WriteLine("Task1 count {0}", list.Count);
    }

    public void Task2(object obj)
    {
        lock (list.SyncRoot)
        {
            for (int i = 0; i < 500000; i++)
            {
                list.Add(i);
            }
        }
        Console.WriteLine("Task2 count {0}", list.Count);
    }
}

二，ConcurrentQueue .Net自带的支持多线程队列

/// <summary>
/// 多线程处理数据（无返回值）
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="list">待处理数据</param>
/// <param name="action">数据处理方法（有参数无返回值）</param>
/// <param name="count">处理线程数量</param>
/// <param name="waitFlag">是否等待执行结束</param>
static void RunTask<T>(List<T> list, Action<T> action, int threadCount = 5, bool waitFlag = true)
{
<T> queue = new ConcurrentQueue<T>(list);
Task[] tasks = new Task[threadCount];
for (int i = 0; i < threadCount; i++)
{
tasks[i] = Task.Run(() =>
{
while (queue.TryDequeue(out T t))
{
action(t);
}
});
}
if (waitFlag)
{
Task.WaitAll(tasks);
}
}

/// <summary>
/// 多线程处理数据（返回处理后列表）
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="list">待处理数据</param>
/// <param name="func">数据处理方法（有参数有返回值）</param>
/// <param name="threadCount">处理线程数量</param>
/// <returns>数据处理后结果</returns>
static List<T> RunTask<T>(List<T> list, Func<T, T> func, int threadCount = 5)
{
var result = new List<T>();
ConcurrentQueue<T> queue = new ConcurrentQueue<T>(list);
Task<List<T>>[] tasks = new Task<List<T>>[threadCount];
for (int i = 0; i < threadCount; i++)
{
tasks[i] = Task.Run<List<T>>(() =>
{
var rList = new List<T>();
while (queue.TryDequeue(out T t))
{
rList.Add(func(t));
}
return rList;
});
}
Task.WaitAll(tasks);
for (int i = 0; i < threadCount; i++)
{
result.AddRange(tasks[i].Result);
}
return result;
}

//----------------------Test-----------------

List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//输出列表中的数据，且加上“action”字符前缀
RunTask<int>(list, d => { Console.WriteLine("action" + d); });

//对列表中数据都执行 “*2” 的操作
var result = RunTask<int>(list, d => { return d * 2; });
result.ForEach(d => Console.WriteLine(d));

效率提示的题外总结：

HashTable中的key/value均为object类型，由包含集合元素的存储桶组成。存储桶是 HashTable中各元素的虚拟子组，与大多数集合中进行的搜索和检索相比，存储桶可令搜索和检索更为便捷。每一存储桶都与一个哈希代码关联，该哈希代码是使用哈希函数生成的并基于该元素的键。HashTable的优点就在于其索引的方式，速度非常快。如果以任意类型键值访问其中元素会快于其他集合，特别是当数据量特别大的时候，效率差别尤其大。
HashTable的应用场合有：做对象缓存，树递归算法的替代，和各种需提升效率的场合。
Hashtable 与Dictionary 区别
1，HashTable是经过优化的，访问下标的对象先散列过，所以内部是无序散列的，保证了高效率，也就是说，其输出不是按照开始加入的顺序，而Dictionary遍历输出的顺序，就是加入的顺序，这点与Hashtable不同
2，HashTable 不用 装箱。
System.Collections.Hashtable ht = new System.Collections.Hashtable();
ht.Add(1, "apple");