C#的变迁史

　　作为多线程和并行计算不得不考虑的问题就是临界资源的访问问题，解决临界资源的访问通常是加锁或者是使用信号量，这个大家应该很熟悉了。

　　而集合作为一种重要的临界资源，通用性更广，为了让大家更安全的使用它们，微软为我们带来了强大的并行集合：System.Collections.Concurrent里面的各位仁兄们。

　　首先，咱们从一个经典的问题谈起。

生产者消费者问题

　　这个问题是最为经典的多线程应用问题，简单的表述这个问题就是：有一个或多个线程(生产者线程)产生一些数据，同时，还有一个或者多个线程(消费者线程)要取出这些数据并执行一些相应的工作。如下图所示：

　　下面就是使用程序去描述这个问题了。

　　最直接的想法可能是这样：

static void Main(string[] args)
{
    int count = 0;
    // 临界资源区
    var queue = new Queue<string>();
    // 生产者线程
    Task.Factory.StartNew(() =>
    {
        while (true)
        {
            queue.Enqueue("value" + count);
            count++;
        }
    });

    // 消费者线程1
    Task.Factory.StartNew(() =>
    {
        while (true)
        {
            if (queue.Count > 0)
            {
                string value = queue.Dequeue();
                Console.WriteLine("Worker 1: " + value);
            }
        }

    });
    // 消费者线程2
    Task.Factory.StartNew(() =>
    {
        while (true)
        {
            if (queue.Count > 0)
            {
                string value = queue.Dequeue();
                Console.WriteLine("Worker 2: " + value);
            }
        }

    });

    Thread.Sleep(50000);
}

　　使用Queue<string>模拟了一个简单的资源池，一个生产者放数据，两个消费者消费数据。上面这个程序运行以后会产生异常，异常的原因很简单，当某个时刻，第一个消费者判断queue.Count > 0为true时，就会到Queue中取数据，但是这个时候数据可能会被第二个消费者拿走了，因为第二个消费者也判断出此时有数据可取。这是一个简单的临界资源线程安全问题。

　　知道问题了，那么如何解决呢？
　　第一种方案是加锁，这个方案是可行的，很多时候我们也是这么做的，包括微软早期实现线程安全的ArrayList和Hashtable内部(Synchronized方法)也是这么实现的。这个方案适用于只有少量的消费者，并且每个消费者都会执行大量操作的时候，这时lock并没什么太大问题，但是，如果是大批量短小精悍的消费者存在的话，lock会严重影响代码的执行效率。
　　第二种方案就是我们直接用新的线程安全的集合区解决这个问题。新的线程安全的这些集合内部不再使用lock机制这种比较低效的方式去实现线程安全，而是转而使用SpinWait和Interlocked等机制，间接实现了线程安全，这种方式的效率要高于使用lock的方式。看一下实现代码：

var queue = new ConcurrentQueue<string>();
Task.Factory.StartNew(() =>
{
    while (true)
    {
        queue.Enqueue("value" + count);
        count++;
    }
});

Task.Factory.StartNew(() =>
{
    while (true)
    {
        string value;
        if (queue.TryDequeue(out value))
        {
            Console.WriteLine("Worker 1: " + value);
        }
    }
});

Task.Factory.StartNew(() =>
{
    while (true)
    {
        string value;
        if (queue.TryDequeue(out value))
        {
            Console.WriteLine("Worker 2: " + value);
        }

    }
});

　　执行这段代码，可以工作，但是有点不太优雅，能不能不要去判断集合是否为空？集合当自己没有元素的时候自己Block一下可以吗？答案当然是可以的，使用BlockingCollection即可：

var blockingCollection = new BlockingCollection<string>();
Task.Factory.StartNew(() =>
{
    while (true)
    {
        blockingCollection.Add("value" + count);
        count++;
    }
});

Task.Factory.StartNew(() =>
{
    while (true)
    {
        Console.WriteLine("Worker 1: " + blockingCollection.Take());
    }
});

Task.Factory.StartNew(() =>
{
    while (true)
    {
        Console.WriteLine("Worker 2: " + blockingCollection.Take());
    }
});

　　BlockingCollection集合是一个拥有阻塞功能的集合，它就是完成了经典生产者消费者的算法功能。它没有实现底层的存储结构，而是使用了实现IProducerConsumerCollection接口的几个集合作为底层的数据结构，例如ConcurrentBag， ConcurrentStack或者是ConcurrentQueue。你可以在构造BlockingCollection实例的时候传入这个参数，如果不指定的话，则默认使用ConcurrentQueue作为存储结构。

　　而对于生产者来说，只需要通过调用其Add方法放数据，消费者只需要调用Take方法来取数据就可以了。
　　当然了上面的消费者代码中还有一点是让人不爽的，那就是while语句，可以更优雅一点吗？答案还是肯定的：

Task.Factory.StartNew(() =>
{
        foreach (string value in blockingCollection.GetConsumingEnumerable())
        {
            Console.WriteLine("Worker 1: " + value);
        }
});

　　GetConsumingEnumerable()方法是关键，这个方法会遍历集合取出数据，一旦发现集合空了，则阻塞自己，直到集合中又有元素了再开始遍历，神奇吧。

　　好了，到此完美了解决了生产者消费者问题。然而通常来说，还有两个问题我们有时需要去控制：

第一个问题：控制集合中数据的最大数量。

　　这个问题由BlockingCollection构造函数解决，构造该对象实例的时候，构造函数中的BoundedCapacity决定了集合最大的可容纳数据数量，这个比较简单，不多说了。

第二个问题：何时停止的问题。

　　这个问题由CompleteAdding和IsCompleted两个配合解决。
　　CompleteAdding方法是直接不允许任何元素被加入集合；当使用了CompleteAdding方法后且集合内没有元素的时候，另一个属性IsCompleted此时会为True，这个属性可以用来判断是否当前集合内的所有元素都被处理完。看一下生产者修改后的代码：

Task.Factory.StartNew(() =>
{
    for (int count = 0; count < 10; count++)
    {
        blockingCollection.Add("value" + count);
    }

    blockingCollection.CompleteAdding();
});

　　当使用了CompleteAdding方法后，对象停止往集合中添加数据，这时如果是使用GetConsumingEnumerable枚举的，那么这种枚举会自然结束，不会再Block住集合，这种方式最优雅，也是推荐的写法。但是如果是使用TryTake访问元素的，则需要使用IsCompleted判断一下，因为这个时候使用TryTake会抛InvalidOperationException异常。

看一下最终的代码形式：

static void Main(string[] args)
{
    var blockingCollection = new BlockingCollection<string>();
    var producer = Task.Factory.StartNew(() =>
    {
        for (int count = 0; count < 10; count++)
        {
            blockingCollection.Add("value" + count);
            Thread.Sleep(300);
        }

        blockingCollection.CompleteAdding();
    });

    var consumer1 = Task.Factory.StartNew(() =>
    {
        foreach (string value in blockingCollection.GetConsumingEnumerable())
        {
            Console.WriteLine("Worker 1: " + value);
        }
    });

    var consumer2 = Task.Factory.StartNew(() =>
    {
        foreach (string value in blockingCollection.GetConsumingEnumerable())
        {
            Console.WriteLine("Worker 2: " + value);
        }
    });

    Task.WaitAll(producer, consumer1, consumer2);
}

BlockingCollection的枚举

　　此外，需要注意BlockingCollection有两种枚举方法，首先BlockingCollection本身继承自IEnumerable<T>，所以它自己就可以被foreach枚举，首先BlockingCollection包装了一个线程安全集合，那么它自己也是线程安全的，而当多个线程在同时修改或访问线程安全容器时，BlockingCollection自己作为IEnumerable会返回一个一定时间内的集合片段，也就是只会枚举在那个时间点上内部集合的元素。使用这种方式枚举的时候，不会有Block效果。
　　另外一种方式就是我们上面使用的GetConsumingEnumerable方式的枚举，这种方式会有Block效果，直到CompleteAdding被调用为止。

　　最后提一下实现IProducerConsumerCollection接口的几个集合：ConcurrentBag(线程安全的无序的元素集合)， ConcurrentStack(线程安全的堆栈)和ConcurrentQueue(线程安全的队列)。这些都很简单，功能与非线程安全的那些集合都一样，只不多是多了TryXXX方法，多线程环境下使用这些方法就好了，其他就不多说了。

　　到此生产者和消费者这个经典的问题告一段落了。

　　System.Collections.Concurrent下面的集合除了解决生产者消费者问题外，还有一些与多线程相关的集合，例如：

1. ConcurrentDictionary，这个是键/值对字典的线程安全实现，这个类在原来的基础上也添加了一下新的方法，例如：AddOrUpdate，GetOrAdd，TryXXX等等，都很容易理解。

2. 各种Partitioner 类，提供针对数组、列表和可枚举项的常见分区策略。

　　若要对数据源操作进行并行化，其中一个必要步骤是将源分区为可由多个线程同时访问的多个部分。 PLINQ 和任务并行库 (TPL) 提供了默认的分区程序，当编写并行查询或ForEach循环时，默认的分区程序以透明方式工作。 但是毫无疑问，对于一些复杂的情况，我们是可以插入自己的分区程序的，这就是微软为我们提供的各种Partitioner类，这个不多说了，感兴趣的同学请自己参考一下MSDN。