线程

今天师傅教了一个线程入门知识点，以备后面使用：

 class Program
    {
        static void Main(string[] args)
        {
                Stopwatch watch = Stopwatch.StartNew();

                ////业务1  拿到起返回值
                //var t1 = T1();
                //Console.WriteLine("hhh");
                ////业务2   拿到返回值
                //var t2 = T2();
                //Console.WriteLine("hhh2");
                //string t = t1 + t2;
                
                var task1 = Task.Run(() =>
                    {
                        return T1();
                    });
                Console.WriteLine("hhh");

                var task2 = Task.Run(() =>
                {
                    return T2();
                });
                Console.WriteLine("hhh2");

                Task.WhenAll(task1, task2);

                string t = task1.Result + task2.Result;
            

            //要把业务1的返回值和业务2的返回值拼接起来，输出


            watch.Stop();
            var time = watch.ElapsedMilliseconds;

            Console.WriteLine(t);
            Console.WriteLine("耗时：{0}", watch.ElapsedMilliseconds);

            Console.ReadKey();

        }

        public static string T1()
        {
            Thread.Sleep(3000);

            return "Msg1";
        }

        public static string T2()
        {
            Thread.Sleep(5000);

            return "Msg2";
        }
    }
       

输入结果：

task1和task2都为子线程。而直接输出hhh和hhh2，分别占用的是task1和task2子线程的时间。主线程走到task1和task2只是执行了开启（秒开）。

执行到 Task.WhenAll(task1, task2);的时候，才输出共消耗的时间（等待所有任务结束使用）

格式化显示时间：

           {   //格式化显示时间
                TimeSpan ts = watch.Elapsed;
                // Format and display the TimeSpan value.
                string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
                    ts.Hours, ts.Minutes, ts.Seconds,
                    ts.Milliseconds / 10);
                Console.WriteLine("RunTime " + elapsedTime);
            }        

 

task1 和  task2 两个任务在定义之后就已经马不停蹄的在子线程中运行了，Task.WaitAll 是一个等待的过程，参数就是Task参数，一旦全部执行完毕了，就继续往下执行，这里是阻塞的，还是比较好理解的。

这样的话WaitAny就很好理解了，就是参数里面的Task 有任意一个执行完成，就继续执行后面的逻辑

WhenAll

WhenAll其实跟WaitAll是为了实现一样的功能，只是在WaitAll基础上又做了一层包装，

                Task.WhenAll(task1, task2).ContinueWith(p =>
                {
                   
                }, TaskContinuationOptions.OnlyOnRanToCompletion);

1.WaitAny（执行的线程等待其中任何一个线程执行完毕即可执行）

2.WaitAll（执行的线程等待其中所有线程执行完毕方可执行）

 var t1=Task.Run(() =>
            {
                Console.WriteLine("demo1,当前线程id为：" + Thread.CurrentThread.ManagedThreadId + ",当前时间为" + watch.ElapsedMilliseconds);
            });
            var t2 = Task.Run(() =>
            {
                Console.WriteLine("demo2,当前线程id为：" + Thread.CurrentThread.ManagedThreadId + ",当前时间为" + watch.ElapsedMilliseconds);
            });
            var t3 = Task.Run(() =>
            {
                Console.WriteLine("demo3,当前线程id为：" + Thread.CurrentThread.ManagedThreadId + ",当前时间为" + watch.ElapsedMilliseconds);
            });
            var t4 = Task.Run(() =>
            {
                Console.WriteLine("demo4,当前线程id为：" + Thread.CurrentThread.ManagedThreadId + ",当前时间为" + watch.ElapsedMilliseconds);
            });
            var t5 = Task.Run(() =>
            {
                Console.WriteLine("demo5,当前线程id为：" + Thread.CurrentThread.ManagedThreadId + ",当前时间为" + watch.ElapsedMilliseconds);
            });
            var t6= Task.Run(() =>
            {
                Console.WriteLine("demo6,当前线程id为：" + Thread.CurrentThread.ManagedThreadId + ",当前时间为" + watch.ElapsedMilliseconds);
            });
            Task.WaitAll(t1,t2,t3,t4,t5,t6);
            Console.WriteLine("执行完毕，WaitAll，线程id为:" + Thread.CurrentThread.ManagedThreadId + "耗时为：" + watch.ElapsedMilliseconds);
            Console.ReadKey();