线程同步 资源锁定(四)Barrier类

Barrier类用于设置一个屏障，使程序都到达屏障后，再继续执行。适合于多个任务分工执行，却又需要合并工作的情形。

  class Program
    {
        static void Main(string[] args)
        {
            const int numberTask = 2;
            const int partitionSize = 1000000;
            var data = new List<string>(FillData(numberTask * partitionSize));//填充测试数据.


            var barrier=new Barrier(numberTask);//定义参与线程数量.?为什么会加1


            var Tasks=new Task<int[]>[numberTask];//定义返回值是int[]的Task数组.


            for (int i = 0; i < numberTask; i++)
            {
                int jobnumber=i;
                Tasks[i] = Task.Run(() => CalculationInTask(jobnumber, partitionSize, barrier, data));
            }
            barrier.SignalAndWait();// 发出参与者已达到屏障并等待所有其他参与者也达到屏障。
            var resultCollection = Tasks[0].Result.Zip(Tasks[1].Result, (c1, c2) =>
                {
                    return c1 + c2;
                });//连接两个结果集(相加).
            char ch = 'a';
            int sum = 0;
            foreach (var x in resultCollection)
            {
                Console.WriteLine("{0}, count: {1}", ch++, x);
                sum += x;
            }


            Console.WriteLine("main finished {0}", sum);
            Console.WriteLine("remaining {0}, phase {1}", barrier.ParticipantsRemaining, barrier.CurrentPhaseNumber);


            Console.ReadKey();
        }
        /// <summary>
        /// 参与运算的程序
        /// </summary>
        /// <param name="jobnumber">工作程序序列</param>
        /// <param name="partitionSize">分段计算的部分</param>
        /// <param name="barrier">分段的参与的调配者</param>
        /// <param name="list">需要分段的总集合</param>
        /// <returns></returns>
        static int[] CalculationInTask(int jobnumber,int partitionSize,Barrier barrier,IList<string> list)
        {
            List<string> data = new List<string>(list);
            //计算开始和结束的List集合.
            int start = jobnumber * partitionSize;
            int end = start + partitionSize;
            //准备用于存放出现次数的集合.
            int[] charCount = new int[26];
            for (int i =start; i < end; i++)
            {
                char c = data[i][0]; //获取集合的第一个字符;
                charCount[c - 97]++;//减去97后，得到26个字符的顺序，然后依次自加1，即得到它出现的次数。此代码有意思。
            }
            barrier.RemoveParticipant();//通知Barrier,将减少一个参与者.
            return charCount;
        }
        /// <summary>
        /// 生成一个指定大小的string集合。
        /// </summary>
        /// <param name="size">集合大小</param>
        /// <returns>string集合</returns>
        private static IEnumerable<string> FillData(int size)
        {
            List<string> stringList = new List<string>(size);
            Random r = new Random();
            for (int i = 0; i < size; i++)
            {
                stringList.Add(GetString(r));
            }
            return stringList;
        }
        /// <summary>
        /// 随机生成6个字节的字符串
        /// </summary>
        /// <param name="r">随机数</param>
        /// <returns>6个字节的字符串</returns>
        private static string GetString(Random r)
        {
            Random R = r;
            StringBuilder sb = new StringBuilder(6);//设置起始大小至少是6个字节.
            for (int i = 0; i < 6; i++)
            {
                sb.Append((Char)(R.Next(26) + 97));
            }
            return sb.ToString();
        }
  }