多线程处理复杂计算，单线程输出顺序结果---一个苹果的加工过程

这个标题写的很抽象，一时间您可能不明白，什么是“多线程处理复杂计算，单线程输出顺序结果”。我先叙述一个场景说明吧。

苹果的加工过程，有一片苹果园，正在源源不断的长成熟新的苹果。苹果的加工有3道手续

0. 采摘入库，得到未清洗的新苹果，每个苹果都有顺序得到的新编号。

1. 处理每个苹果，清洗，消毒去垢等。

2. 将步骤1处理完成的苹果，按照采摘顺序逐个打上标签出售。

步骤0采摘与步骤2打标签的速度是超级快的，但是步骤1的处理就比较慢比较耗时。

解决方案，构造一个苹果队列用于存储苹果，步骤0顺序生成，步骤1多线程并非处理，步骤2顺序输出。

 

道理比较简单，接下来直接上图。

 

1.首先定义苹果对象。

    public class Apple
    {
       
        public  long ID { get; set; }

        /// <summary>
        /// 0初始，1去皮，2贴标签
        /// </summary>
        public  int State { get; set; }

        public string Name
        {
            get
            {
                switch (State)
                {
                    case 0:
                        return "初始";
                    case 1:
                        return "去皮";
                    case 2:
                        return "贴标签";
                    default:
                        return "";
                }
            }
        }

    }

 

 

2.整体逻辑

        public void Start()
        {
            //随机生成新苹果
            new Thread(MakerAppleMethod).Start();

            //多线程去皮
            new Thread(QuPiMethod).Start();

            //单线程贴标签
            new Thread(DaoSuiMethod).Start();

            //监控
            new Thread(EyeMethod).Start();
        }

 

 

3.生成苹果的线程

#region 1分钟生成20个苹果

        public long MaxAppleId = 0;
        public List<Apple> apples = new List<Apple>();

        public void MakerAppleMethod()
        {
            while (true)
            {
                Apple app = new Apple();
                app.ID = MaxAppleId++;
                LogHelper.Log("生成苹果", $"{app.ID}生成苹果[{DateTime.Now.ToString("HH:m:s fff")}]");
                apples.Add(app);
                Thread.Sleep(200);
            }
        }

        #endregion

 

 

 

4. 苹果清理的过程

        /// <summary>
         /// 多线程去皮
         /// </summary>
        private void QuPiMethod()
        {
            while (true)
            {
                var applist = apples.ToArray().Take(20).Where(o => o.State == 0).ToList();
                List<Task>taskList=new List<Task>();
                foreach (var apple in applist)
                {
                    Task task=new Task(delegate()
                    {
                        #region 去皮过程
                        var wait = mRad.Next(9999);
                        Thread.Sleep(wait);
                        apple.State = 1;
                        LogHelper.Log("去皮", $"{apple.ID}完成去皮[{DateTime.Now.ToString("HH:m:s fff")}]");

                        #endregion
                    });
                    task.Start();
                    taskList.Add(task);
                }
                Task.WaitAll(taskList.ToArray());
                Thread.Sleep(20);
            }
        }

 

 

5. 贴标签线程

        /// <summary>
        /// 单线程按照顺序贴标签
        /// </summary>
        private void DaoSuiMethod()
        {
            while (true)
            {
                if (apples.Count>0&&apples[0].State==1)
                {
                    #region 捣碎过程

                    apples[0].State = 2;
                    LogHelper.Log("贴标签", $"{apples[0].ID}完成贴标签[{DateTime.Now.ToString("HH:m:s fff")}]");
                    apples.RemoveAt(0);

                    #endregion
                }
                else
                {
                    Thread.Sleep(10);
                }
            }
        }

 

 

6.全局监控线程

        /// <summary>
        /// 监控
        /// </summary>
        private void EyeMethod()
        {
            while (true)
            {
                string msg = string.Empty;
                var group = apples.ToArray().GroupBy(o => o.State);
                foreach (var gg in group)
                {
                    var item = gg.ToList();
                    msg += item[0].Name + ":" + item.Count + "\t\t";
                }
                LogHelper.Log("EYE",msg);
                Thread.Sleep(1000);
            }
        }

 

 

 

完成~~~