并行线程代码

  /// <summary>
    /// Parallel并行线程  
    /// </summary>
    public class Parallel1
    {
        public static Stopwatch sw = new Stopwatch();
        public List<int> list1 = new List<int>();
        public Dictionary<string, int> dic = new Dictionary<string, int>();
     
        #region 并行
        public void SetListOrDic()
        {
            sw.Stop();
            sw.Restart();
            for (int i = 0; i < 1000; i++)
            {


                list1.Add(i);
            }
            sw.Stop();
            Console.WriteLine("执行List的时间" + sw.Elapsed);


            sw.Restart();
            for (int i = 0; i < 1000; i++)
            {
                dic.Add("dic" + i, i);
            }


            sw.Stop();
            Console.WriteLine("执行dic的时间" + sw.Elapsed);


            sw.Restart();
            int s = 0;
            foreach (var item in list1)
            {


                s += item;




            }
            sw.Stop();
            Console.WriteLine("遍历list的时间" + sw.Elapsed + "结果为" + s);


            sw.Restart();
            int w = 0;
            foreach (var item in dic)
            {


                w += item.Value;
            }
            sw.Stop();
            Console.WriteLine("遍历dic的时间" + sw.Elapsed + "结果为" + w);
        }






        public static void Run1()
        {
            Thread.Sleep(2000);
            Console.WriteLine("阻塞2000");
        }
        public static void Run2()
        {
            Thread.Sleep(3000);
            Console.WriteLine("阻塞3000");


        }


        /// <summary>
        /// 打印并行执行操作
        /// </summary>
        public void Run1AndRun2()
        {
            sw.Start();


            Parallel.Invoke(Run1, Run2);//并行执行操作方法
            sw.Stop();
            Console.WriteLine("并行时间：" + sw.ElapsedMilliseconds);
            sw.Restart();
            Run1();
            Run2();
            sw.Stop();
            Console.WriteLine("run1+run2的时间" + sw.ElapsedMilliseconds);




        }
        /// <summary>
        /// 结束并行操作
        /// </summary>
        public void BreakOrStop()
        {
            ConcurrentBag<int> con = new ConcurrentBag<int>();//表示对线程安全的无序集合
            sw.Start();
            //使用stop
            Parallel.For(0, 1000, (i, state) =>
            {
                if (con.Count() == 300)
                {
                    state.Stop();
                    return;
                }
                con.Add(i);




            });


            sw.Stop();
            Console.WriteLine("集合数" + con.Count + "时间" + sw.ElapsedMilliseconds);
            sw.Restart();
            //使用break
            Parallel.For(0, 1000, (i, state) =>
            {
                if (con.Count() == 300)
                {
                    state.Break();
                    return;
                }
                con.Add(i);




            });
            sw.Stop();
            Console.WriteLine("集合数" + con.Count + "时间" + sw.ElapsedMilliseconds);


        }


        #endregion
    }




    /// <summary>
    /// 并行Linq
    /// </summary>
    public class ParallelLinq
    {
        Stopwatch sq = new Stopwatch();


        List<Custom> ListByCustom = new List<Custom>();
        public void Plinq()
        {


           
            try
            {
                for (int i = 0; i < 2000000; i++)
                {
                       ListByCustom.Add(new Custom { Adress = "adress" + i, Age = i, Name = "namne" + i });
                    
                }
                #region AsParallel()表示 把当前查询并行化
                sq.Start();
                var list = ListByCustom.Where(i => i.Age > 55).ToList();


                sq.Stop();
                Console.WriteLine("普通linq时间为" + sq.ElapsedMilliseconds);


                sq.Restart();
                sq.Start();
                //AsParallel()表示 把当前查询并行化
                var list1 = ListByCustom.AsParallel().Where(i => i.Age > 55).ToList();
                sq.Stop();
                Console.WriteLine("并行Linq时间为" + sq.ElapsedMilliseconds);


                #endregion


                #region Group 与ToLookup
                sq.Restart();
                var listgroup = ListByCustom.GroupBy(i => i.Age).ToList();


                sq.Stop();
                Console.WriteLine("Group时间"+sq.ElapsedMilliseconds);


                sq.Restart();
                var listgroup1 = ListByCustom.ToLookup(i => i.Age).ToList();


                sq.Stop();
                Console.WriteLine("ToLookup时间" + sq.ElapsedMilliseconds);
                #endregion






            }
            catch (ArgumentNullException ex)
            {
                Console.WriteLine(ex);
                sq.Stop();


            }
        }






        /// <summary>
        /// 并行辅助类
        /// </summary>
        public class Custom
        {
            public string Name { get; set; }
            public int Age { get; set; }
            public string Adress { get; set; }
        }


    }




    /// <summary>
    /// Task任务，两种创建方式
    /// var t1=new Task(()=>{直接new
    ///    
    /// });
    /// 
    /// var t2=Task.Factory.StartNew(()=>{工厂模式创建
    /// 
    /// });
    /// </summary>
    public class GetTask {
    
        public void GetTasks() {
            //第一种创建方式 必须手动start
            var t1 = new Task(() => {
                Console.WriteLine("开始t1");
                Thread.Sleep(1000);//阻塞1秒
                Console.WriteLine("task1");
              
               
            });
            t1.Start();//使用new方式创建时必须手动start
            ///Task.Wait()等待线程完成，Task.WaiitAll()等待所有线程完成
            ///
            t1.Wait();//等待当前线程完成才执行其他代码
           
            //第二种方式直接开启
            var t2 = Task.Factory.StartNew(() => {
                Console.WriteLine("开始t2");


                Thread.Sleep(2000);
                Console.WriteLine("task2");
            
            });
            var t3 = Task.Factory.StartNew(() => {
                Console.WriteLine("开始t3");


                Thread.Sleep(2000);
                Console.WriteLine("task3");
            
            });
            //等待所有的线程完成才执行其他代码
            //Task.WaitAll(t2,t3);
            //等效的还有Task.WaitAny，表示任意线程执行完后才执行
            //ContinueWith自动执行
            Console.WriteLine("线程完成");


            var result = t1.ContinueWith(task => {
                Console.WriteLine("自动线程");
                return "this is result";
            
            });
            Console.WriteLine(result.Result.ToString());




            #region Task嵌套 TaskCreationOptions.AttachedToParent指定将任务附加到当前结构层次的父级 qt与pt对比
            var qt = Task.Factory.StartNew(() => {
                var qt1 = Task.Factory.StartNew(() => {
                    Thread.Sleep(1000);
                    Console.WriteLine("this is Child1");
                 });


                Console.WriteLine("parent task1");
            });
            qt.Wait();
            Console.WriteLine("当前操作主任务qt并不会等待子任务qt1执行完才打印此消息");






            var pt = Task.Factory.StartNew(() =>
            {
                var pt1 = Task.Factory.StartNew(() => {
                    Thread.Sleep(1000);
                    Console.WriteLine("this is Child2");
                
                },TaskCreationOptions.AttachedToParent);


                Console.WriteLine("parent Task2");
            });
            pt.Wait();
            Console.WriteLine("主任务等待子任务执行完才打印此消息，关键字的作用TaskCreationOptions.AttachedToParent");
            #endregion
            Console.WriteLine("----------------------------------------------------------------");
            #region Task嵌套例子
            //描述：
           
            //C1得到主任务返回的1+2
            //C2得到主任务返回的1+3
            //C1的子任务的到C1的结果加上4
            //最后，将任务合并，输出结果
          


         
                var Ztsk = Task.Factory.StartNew<int>(() => {
                    Console.WriteLine("开始主任务");
                    return 1;
                });
                //等待主任务完成
                Console.WriteLine("结果"+Ztsk.Result);
                Ztsk.Wait();
                //任务C2
                var C2 = Task.Factory.StartNew<int>(() =>
                {
                    Console.WriteLine("开始任务C2");
                    return Ztsk.Result + 3;
                  
                });
                Console.WriteLine("结果"+C2.Result);
            //任务C1
                var C1 = Task.Factory.StartNew<int>(() =>
                {
                    Console.WriteLine("开始任务C1");
                    return Ztsk.Result + 2;
                }).ContinueWith<int>(task => {
                    Console.WriteLine("开始任务C1的子任务");
                    return task.Result + 4;
                });
                Console.WriteLine("结果" + C1.Result);
            
            //等待所有任务完成
                Task.WaitAll(C1,C2);
            
            //打印结果


                Console.WriteLine("结果为"+(C2.Result+ C1.Result));
            
            
            
        




            #endregion
             Console.WriteLine("-----------------------------Task多线程问题 -----------------------------------");
         
        }


        #region Task多线程问题
        /* 1，死锁
              如果我们在调用Task.WaitAll方法等待所有线程时
           * ，如果有一个Task一直不返回，会出现什么情况呢？
           * 当然，如果我们不做出来的话，程序会一直等待下去，
           * 那么因为这一个Task的死锁，导致其他的任务也无法正常提交
           * ，整个程序"死"在那里
           */
        #region //死锁例子
        public void TaskError()
        {var ts1 = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("死锁任务");
                while (true)
                {
                    Console.WriteLine("1");
                }




            });
            var ts2 = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("Task 2");
                Thread.Sleep(1000);
                Console.WriteLine("结束任务");


            });
            Task.WaitAll(ts1, ts2);
 }
        #endregion




        #region   //解决死锁，即设定最大等待时间，操过时间就退出
        public void RemoveSs() {
            Task[] task = new Task[2];
            task[0] = Task.Factory.StartNew(() => {
                Console.WriteLine("Task 1 Start running...");
                while (true)
                {
                    Thread.Sleep(3000);
                    Console.WriteLine("Task 1 Finished!");
                }
              
            
            });


            task[1] = Task.Factory.StartNew(() => {
                Console.WriteLine("Task 2 Start running...");
                System.Threading.Thread.Sleep(2000);
                Console.WriteLine("Task 2 Finished!");
            
            });
            //等待的最大时间 为5秒
            Task.WaitAll(task,5000);


            for (int i = 0; i < task.Length; i++)
            {
                if (task[i].Status!=TaskStatus.RanToCompletion)
                {
                    Console.WriteLine("任务{0}没有执行完",task[i].Id);
                }
            }
        }
        #endregion






        #endregion
        #region 计算例子
        public void GetResult() {


            bool su = false;
            var t1 = Task.Factory.StartNew<int>(() => {
                Console.WriteLine("第一个数字");


                return 1;
            });
            t1.Wait();


            var t2 = Task.Factory.StartNew<int>(() =>
            {
                Console.WriteLine("开始计算");
                return 5;


            }).ContinueWith(state => {
                if ((t1.Result + state.Result) >= 6)
                    Console.WriteLine("大于");
                else
                {
                    Console.WriteLine("不大于");
                }
            
            });
        
        
        }
        #endregion


    }