.net 4.0 中对多线程新特性（三）

在4.0之前如果需要在多线程环境下操作集合类型的对象往往需要额为每种操作添加比较复杂的锁机制才能保证每个线程对资源的访问安全，在4.0的Collection名称空间下面又多了一个新的名称空间Concurrent，在这个名称空间下面增加了几个非常有用的线程安全的类：
BlockingCollection<T>                    为实现 IProducerConsumerCollection<(Of <(T>)>) 的线程安全集合提供阻止和限制功能。
ConcurrentBag<T>                        表示对象的线程安全的无序集合。
ConcurrentDictionary<key,value>    表示可由多个线程同时访问的键值对的线程安全集合。
ConcurrentQueue<T>                    表示线程安全的先进先出 (FIFO) 集合。
ConcurrentStack<T>                     表示线程安全的后进先出 (LIFO) 集合。
OrderablePartitioner<T>                 表示将一个可排序数据源拆分成多个分区的特定方式。
Partitioner                                     提供针对数组、列表和可枚举项的常见分区策略。
Partitioner<T>                               表示将一个数据源拆分成多个分区的特定方式。

通一个简单的例子可以非常容易的来应用这些特性

class Program
    {
        static ConcurrentDictionary<int, int> dict = new ConcurrentDictionary<int, int>();

        static void Main(string[] args)
        {
            for (int i = 0; i < 5; i++)
            {
                var thread = new Thread(new ThreadStart(Action));
                thread.Start();
            }

            Console.Read();
        }

        static void Action()
        {
            var rd = new Random();
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(rd.Next(1, 5));
                var ok = dict.TryAdd(i, i);
                Console.WriteLine("Thread {0} add {1} {2}", Thread.CurrentThread.ManagedThreadId, i, ok ? "success" : "fail");
            }
        }
    }

程序输出如下：

Thread 11 add 0 success
Thread 11 add 1 success
Thread 12 add 0 fail
Thread 13 add 0 fail
Thread 11 add 2 success
Thread 12 add 1 fail
Thread 14 add 0 fail
Thread 12 add 2 fail
Thread 13 add 1 fail

…

从输出结果我们看到在多线程竞争的情况下ConcurrentDictionary能够很好的处理锁竞争的问题。

生产消费模式在多线程中是非常常见的一种模式了，在4.0之前需要一套比较复杂的读写锁来处理处理并发资源竞争的问题，在4.0中借助BlockingCollection<T>  类可以很容易的实现了。即使一个新手也能够非常容易的掌握而不需太多去了解多线程的细节问题。来个简单的例子：

static void Main(string[] args)
        {
            TestCase.Test();

            Console.Read();
        }
class TestCase
    {
        static ConcurrentBag<Product> _bag = new ConcurrentBag<Product>();

        public static void Test()
        {
            var produce = new Thread(new ThreadStart(Produce));
            var consume = new Thread(new ThreadStart(Consume));

            produce.Start();
            consume.Start();
        }

        static void Produce()
        {
            int index = 0;
            while (true)
            {
                if (_bag.IsEmpty)
                {
                    string productName = "Product " + index.ToString();
                    _bag.Add(new Product() { Name = productName });
                    Console.WriteLine("Produce Product {0} ", productName);
                    index += 1;
                }
                Thread.Sleep(1000);
            }
        }

        static void Consume()
        {
            while (true)
            {
                if (!_bag.IsEmpty)
                {
                    Product item;
                    if (_bag.TryTake(out item))
                    {
                        Console.WriteLine("Consume Product {0} " , item.Name);
                    }
                }
                Thread.Sleep(1000);
            }
        }
    }

    class Product
    {
        public string Name { get; set; }
    }

程序输出如下：

Consume Product Product 0
Produce Product Product 1
Consume Product Product 1
Produce Product Product 2
Consume Product Product 2
Produce Product Product 3
Consume Product Product 3
Produce Product Product 4
Consume Product Product 4