C#并发实战Parallel.ForEach使用

     前言：最近给客户开发一个伙食费计算系统，大概须要计算2000我的的伙食。需求是按照员工的预约报餐计划对消费记录进行检查，若有未报餐有刷卡或者有报餐没刷卡的要进行必定的金额扣减等一系列规则。一开始个人想法比较简单，直接用一个for循环搞定，统计结果却是没问题，可是计算出来太慢了须要7，8分钟。这样系统服务是报超时错误的，让人以为有点不太爽。因为时间也很少就就先提交给用户使用了，后面逻辑又增长了，计算时间变长，整个计算一遍竟然要将近10分钟了。这个对用户来讲是能接收的（原来本身手算须要好几天呢），可是我本身接受不了，因而就开始优化了，怎么优化呢，用多线程呗。

     一提到多线程，最早想到的是Task了，毕竟.net4.0以上Task封装了不少好用的方法。可是Task毕竟是多开一些线程去执行任务，最后整合结果，这样能够快一些，但我想更加快速一些，因而想到了另一个对象：Parallel。以前在维护代码是确实有遇到过别人写的Parallel.Invoke，只是指定这个函数的做用是并发执行多项任务，若是遇到多个耗时的操做，他们之间又不贡献变量这个方法不错。个人状况是要并发执行一个集合，因而就用了List.ForAll 这个方法实际上是拓展方法，完整的调用为：List.AsParallel().ForAll，须要先转换成支持并发的集合，等同于Parallel.ForEach，目的是对集合里面的元素并发执行一系列操做。

     因而乎，把原来的foreach换成了List.AsParallel().ForAll，运行起来，果真速度惊人，不到两分钟就插入结果了，但最后倒是报主键重复的错误，这个错误的缘由是，因为使用了并发，这个时候变量自增，实际上是在强着自增，当多个线程同时获取到了id值，都去自增而后就重复了，举个例子以下：

            int num = 1;
            List<int> list = new List<int>();
            for (int i = 1; i <= 2000; i++)
            {
                list.Add(i);
            }
            Console.WriteLine($"num初始值为：" + num.ToString());
            list.AsParallel().ForAll(n =>
            {
                num++;
            });
            Console.WriteLine($"不加锁，并发{list.Count}次后为：" + num.ToString());
            Console.ReadKey();

这段代码是让一个变量执行2000次自增，正常结果应该是2001，但实际结果以下：

有经验的同窗，立马能想到须要加锁了，C#内置了不少锁对象，如lock 互斥锁，Interlocked 内部锁，Monitor 这几个比较常见，lock内部实现其实就是使用了Monitor对象。对变量自增，Interlocked对象提供了，变量自增，自减、或者相加等方法,咱们使用自增方法Interlocked.Increment，函数定义为：int Increment(ref int num),该对象提供原子性的变量自增操做，传入目标数值，返回或者ref num都是自增后的结果。 在以前的基础上咱们增长一些代码：

           num = 1;
            Console.WriteLine($"num初始值为：" + num.ToString());
            list.AsParallel().ForAll(n =>
            {
                Interlocked.Increment(ref num);
            });
            Console.WriteLine($"使用内部锁，并发{list.Count}次后为：" + num.ToString());
            Console.ReadKey();

咱们来看运行结果：

加了锁以后ID重复算是解决了，其实别高兴太早，因为正常的环境有了ID咱们还有用这些ID来构建对象呢，因而又写了写代码，用集合来添加这些ID，为了更真实的模拟生产环境，我在forAll里面又加了一层循环代码以下：

            num = 1;
            Random random = new Random();
            var total = 0;
            var m = new ConcurrentBag<int>();
            list.AsParallel().ForAll(n =>
            {
                var c = random.Next(1, 50);
                Interlocked.Add(ref total, c);
                for (int i = 0; i < c; i++)
                {
                    Interlocked.Increment(ref num);
                    m.Add(num);
                }
            });
            Console.WriteLine($"使用内部锁，并发+内部循环{list.Count}次后为：" + num.ToString());
            Console.WriteLine($"实际值为：{total + 1}");
            var l = m.GroupBy(n => n).Where(o => o.Count() > 1);
            Console.WriteLine($"并发里面使用安全集合ConcurrentBag添加num，集合重复值：{l.Count()}个");
            Console.ReadKey();

上面的代码里面我用到了线程安全集合ConcurrentBag<T>它的命名空间是：using System.Collections.Concurrent，尽管使用了线程安全集合，可是在并发面前仍然是不安全的，到了这里其实比较郁闷了，自增长锁，安全集合内部应该也使用了锁，但仍是重复了。有点说不过去了，想一想多线程执行时有个上下文对象，即当多个线程同时执行任务，共享了变量他们一开始传进去的对象数值应该是相同的，因为变量自增时加了锁，因此ID是不会重复了。我猜想问题应该出在Add方法了，就是说当num值自增后尚未来得及传出去就已经执行了Add方法，故添加了重复变量。因而乎，我从新写了段代码，让ID自增和集合添加都放到锁里面：

            num = 1;
            total = 0;
            using (var q = new BlockingCollection<int>())
            {
                list.AsParallel().ForAll(n =>
                {
                    var c = random.Next(1, 50);
                    Interlocked.Add(ref total, c);
                    for (int i = 0; i < c; i++)
                    {
                        
                       // Task.Delay(100);
                        q.Add(Interlocked.Increment(ref num));
                        
                        //可控
                        //lock (objLock)
                        //{
                        //    num++;
                        //    q.Add(num);
                        //}
                    }

                });
                q.CompleteAdding();
                Console.WriteLine($"num累计值为：{total},并发以后值为：{num}");
                var x = q.GroupBy(n => n).Where(o => o.Count() > 1);
                Console.WriteLine($"并发使用安全集合BlockingCollection+Interlocked添加num，集合重复值：{x.Count()}个");
                Console.ReadKey();
            }

这里我测试了另一个线程安全的集合BlockingCollection，关于这个集合的使用请自行查找MSDN文档，上面的关键代码直接添加安全集合的返回值，能够保证集合不会重复，但其实下面的lock更适用与正式环境，由于咱们添加的通常都是对象不会是基础类型数值，运行结果以下：

至此，咱们的问题解决了，计算时间由原来的9分多降至110秒左右，可见Parallel的处理仍是很给力的，惟一不足的是，很占CPU，执行计算后CPU达到了88%。附上计算结果：

优化先后对比

 

      总结：C#安全集合在并发的状况下其实不必定是安全的，仍是须要结合实际应用场景和验证结果为准。Parallel.ForEach在对循环数量可观的状况下是能够去使用的，若是有共享变量，必定要配合锁作同步处理。仍是得慎用这个方法，若是方法内部有操做数据库的记得增长事务处理，不然就呵呵了。