异步线程 附属篇

C#中的并发编程知识

续接上片，做的进一步分析，本篇如果语述上有问题的，可以忽略

Thread部分

         public class TestThread
        {
            public void RunThread()
            {
            //线程  声明线程时传入方法A,A可以带object类型的参数，没有返回值,
            //如果有参数，start启用的时候传入。默认是前台运行的，就是说在所有的线程走完后才运行结束
                Thread t1 = new Thread(() =>
                {
                    Thread.Sleep(2000);                   
                    Console.WriteLine(222);
                });
                Thread t2 = new Thread((object m) =>
                {
                    Thread.Sleep(6000);                  
                    Console.WriteLine(m);
                });
                t2.IsBackground = true;
                t2.Start(333);
                t1.Start();
                Thread.Sleep(1000);
                Console.WriteLine(111);
            }       
        ######## 测试部分 ########
            TestThread tw = new TestThread();
             tw.RunThread();
            
        结果：
        111
        222
        CLR自动关闭应用程序
        333出不来
        分析：
        Thread 默认是前台运行，前台运行完 CLR自动结束（有的不是，比如说winForm是一直运行着的，如果控制台，比如Console.Read(),保持前台在等待着，也是OK的）
        t1 前台运行  t2后台运行，他们和主线程M一起并行运行
        M         t2         t1        
        停1s      停2s       停6s
        输出111
                 输出222
        --------------------------CLR结束
                         输出333
        ##########################
        //线程池初始化执行方法必须带一个object参数
        //ThreadPool默认带一个object的参, 没有返回值，默认是后台运行的，就是说在只要主线程走完了，直接就完了，不管子线程走完没
            public void RunThreadPool()
            {
                ThreadPool.QueueUserWorkItem((object o) =>
                {
                    Thread.Sleep(6000);
                    Console.WriteLine(222);
                });
                Thread.Sleep(1000);
                Console.WriteLine(111);
            }
        ######## 测试部分 ########
            TestThread tw = new TestThread();
             tw.RunThreadPool();
            
        结果：
        111
        CLR自动关闭应用程序
        222出不来
        分析：
        ThreadPool 默认是后台运行
        ##########################
            public void RunParaller()
            {
              //Parallel是用多个线程执行循环的工具
        //Parallel是个普通顺序执行语句，只是里面开启多个线程跑东西，Parallerl下面的语句还是需要等Parallel执行完后才能执行的
                int result = 0;
                int lockResult = 0;
                object lb = new object();
                Parallel.For(0, 3, (i) =>
                {
                    result = result + 2;
                    //lock只能lock引用类型，利用引用对象的地址唯一作为锁，实现lock中的代码一次只能一个线程访问
                    //lock让lock里的代码在并行时变为串行，尽量不要在parallel中用lock（lock内的操作耗时小，lock外操作耗时大时，并行还是起作用）
                    lock (lb)
                    {
                        lockResult = lockResult + 2;
                        Thread.Sleep(2000);
                        Console.WriteLine("i={0},lockResult={1}", i, lockResult);
                    }
                    Console.WriteLine("i={0},result={1}", i, result);
                });
                Console.WriteLine(11111);
            }
            TestThread tw = new TestThread();
            tw.RunParaller();
            ######## 测试部分 ########
             结果：
             i=0,lockResult=2
             i=0,result=6
             i=1,lockResult=4
             i=1,result=6
             i=2,lockResult=6
             i=2,result=6
             11111
          
             分析：
             这个栗子有点特殊啊，如果循环大了的话，result的值不知道会不会存在问题           
            ##########################
        }
        
        

可以看出，Thread多线程，传入的是没有返回值的方法，不涉及到各个新开的线程返回值的讨论，讨论的是谁先执行完谁后执行完的影响最后结构的问题，讨论域是站在一个方法下，这个方法新开启线程 讨论的，接下来我们要切换到定位多线程执行返回值这块

Task

Task是个什么东西呢，它在线程中的定位是什么，为啥会诞生它，先看下面的例子

        public void TaskApply()
        {
             Console.WriteLine(1111);
             var t= Task.Run(() =>
              {
                  Thread.Sleep(8000);
                  Console.WriteLine(5555);               
              });
              Console.WriteLine(2222);
              Thread.Sleep(1000);
              Console.WriteLine(3333);                                     
        }
         ######## 测试部分 ########
         TestTask tw = new TestTask();
         tw.TaskApply();
         Console.WriteLine(4444);  
           结果：
           1111
           2222  
           (停1s)
           3333
          4444
           ----CLR结束
           5555和6666不会出来   
           分析：
           可以看出Task也是后台运行的线程，
           首先遇到Task ，相当于新运行了一个IsBackground为true的线程，Task.Run里面也走，外面的也走，并行向下执行，外面的2222输出后，停个1s，输出3333，外面的走完了，继续走方法外的，输出4444，方法外的也走完了，这个时候TaskRun还在那Sleep，不管，结果就出来了
          
         ##########################
           从上面看，好像他和IsBackground=true的Thread运行特征好像相似点很高，我们捋一下，首先Thread是有前后台运行的，他传的方法可以带一个object类型的参数，也可以不带，没有返回值，二ThreadPool是必须传一个object的参数的，是后台运行的，也没有返回值。
           但是呢，Task和他们还有有些不填点，Task他传的方法不能带参数，他是后台运行的，重点是可以返回值的，我们可以在想调动它返回值的地方去获取，唯一需要注意的是在获取的时候会阻塞到当前的线程，即Task中的方法和调动他的变成串执行了，当然调用值的时候，可能Task中已经执行完了也不好说。看下面的改动
         
        public void TaskApply2()
        {
             Console.WriteLine(222);
             var t= Task.Run(() =>
              {
                  Thread.Sleep(8000);
                  Console.WriteLine(555);
                  return 666;
              });
              Console.WriteLine(333);
              Thread.Sleep(1000);
              Console.WriteLine(444);
              Console.WriteLine(t.Result);
              Console.WriteLine(777);                                     
        }
         ######## 测试部分 ########
         Console.WriteLine(111);
         TestTask tw = new TestTask();
         tw.TaskApply();
         Console.WriteLine(888);
        结果：
        111
        222 
        333
        444
        555
        666
        777
        888
        分析：
           首先最外面输出 111，然后进入方法B里面，输出222，然后遇到 Task,并行开始了，外面（B）输出333，停个1s，输出444，遇到t.Result,不好意思，得等待Task运行完才能向下执行了，这时候Task.Run里面的8s到了输出555，把返回值返出来，外面(B)的输出666，接着输出777，最后最外面输出888
           可以看出 如果不调返回值的话，外面(B)是是不会阻塞着等待Task.Run里面的执行完再执行的，这就是Task返回值阻塞的特性
           

当明白上面这个栗子和分析之后，我们看下面几个简单的就很通顺了

            public void RunBackTask()
            {
                Task t = new Task(() =>
                {
                    Thread.Sleep(6000);
                    Console.WriteLine(333);
                });
                t.Start();
                Console.WriteLine(111);
                Thread.Sleep(2000);
                Console.WriteLine(222);
            }
            //外面调用 RunBackTask这个方法的时候 首先是输出 111，停个2s，输出 222，Task的6s还没到，这时候外面的继续跑，这个333输出与否就要看外面的了
            而我们要看下面只个鬼的话
             public void RunTaskGui()
            {
                // 111  222  333 444 555 666  顺序执行              
                var ff = Task.Run(() =>
                {
                    Thread.Sleep(6000);
                    Console.WriteLine(111);
                    return 333;
                }).Result;
                Console.WriteLine(222);
                Console.WriteLine(ff);
                Thread.Sleep(6000);
                Console.WriteLine(444);
            }
            外面的调RunTaskGui()，里面的顺序的走完
            依此是 111 222 333  444，因为 Task.Run（）后直接调了Result，直接阻塞了，这个方法和普通的方法就一样了 
            

从上面我们发现，我们一直在讨论调用方法A里面是怎么执行的，外面的方法肯定是在调用方法A直线完后再直线，即使调用方法A里面有Task的一个异步线程B，那也是新开的一个并行的线程，虽然这个线程B不阻塞他下面的语句和我们外部的方法，我们也是在调用方法B里的走到最后的 } 后再直线我们外面下面的方法

我们现在要切换到，管你调动方法A里面执行什么东东，我外面调用你后，我直接往下面走，看似外面又一层异步的调用

            public int SubTask()
            {
               Thread.Sleep(1000);
                Console.WriteLine(333);
                var ff = Task.Run(() =>
                {
                    Thread.Sleep(6000);
                    Console.WriteLine(555);
                    return 666;
                });
                Console.WriteLine(444);
                Console.WriteLine(ff.Result);
               return 777;
            }
            ######## 测试部分 ########
            Console.WriteLine(111);
            var s=Task.Run(() =>
            {
                TestTask tm = new TestTask();
                return tm.SubTask();            
            });
            Console.WriteLine(222);
            Console.WriteLine(s.Result);
            Console.WriteLine(888);
                             
            结果：
            111
            222 
            333
            444
            555
            666
            777
            888
            这个我就不解释了，应该能顺下来
            

接下来看另一个鬼 async + await

async+await

             public async void RunAwaitTask()
            {
                Thread.Sleep(1000);
                Console.WriteLine(222);
                var ff= await Task.Run(() =>
                {
                    Thread.Sleep(2000);
                    Console.WriteLine(444);
                    return 666;
                });
                Console.WriteLine(555);
                Console.WriteLine(ff);
                Console.WriteLine(777);
            }
             ######## 测试部分 ########
             TestTask tm = new TestTask();
            Console.WriteLine(111);
            tm.RunAwaitTask();
            Console.WriteLine(333);
            //Thread.Sleep(6000);
            //Console.WriteLine(888);
            结果:
            111
            222
            333  --走完后 ClR可能会结束，所以下面不一定会出来
            444
            555
            666
            777
            把 
            //Thread.Sleep(6000);
            //Console.WriteLine(888);
            放开后
            结果是：
            111
            222
            333  
            444
            555
            666
            777
            888
            

它和上面我们讨论的哪个最相似，找找，我们就发现了这货，比较下

        public void TaskApply2()
        {
             Console.WriteLine(222);
             var t= Task.Run(() =>
              {
                  Thread.Sleep(8000);
                  Console.WriteLine(555);
                  return 666;
              });
              Console.WriteLine(333);
              Thread.Sleep(1000);
              Console.WriteLine(444);
              Console.WriteLine(t.Result);
              Console.WriteLine(777);                                     
        }
         ######## 测试部分 ########
         TestTask tw = new TestTask();
         Console.WriteLine(111);
         tw.TaskApply();
         Console.WriteLine(888);
         结果：
        111
        222 
        333
        444
        555
        666
        777
        888          
            

看到异同点了没，看到了没，看到了没，看到了没，没看到说明上面Task的思想没定下来

我们发现调用 一个async的方法，在进去里面一步步执行的时候，遇到await，开始并行了，这个并行现在变成了最外层的调用方法了，而不是里面的语句

从例子看，在执行完Console.WriteLine(222);后，RunAwaitTask这个遇到了await就开始等待了,await下面的语句就阻塞，而最外层的Console.WriteLine(333);可以走了，也就是说，await 的Task运行的和最外层的一起走并行

对于TaskApply2呢，在遇到 Task后，Task下面的语句Console.WriteLine(333);开始执行了，并行的是下面的语句，而不是外面 Console.WriteLine(888);对于Console.WriteLine(888);只是在TaskApply2方法走完 } 后才走，这里面如果把 Console.WriteLine(t.Result);去掉的话，结果又会不一样，但中心区别已经找到了:

async+await 这个 开始并发的点是在遇到await后，外层调用它的和他的Task并行，外层的语句就开始执行了。而普通的Task不会和外层的调用有关系，只会和Task下面的语句开启并行，外层的是在走完 } 后才执行的。

上面只是刚引入 async+await的东西，他们还有各种限制和特征，比如：

异步方法返回类型是Task<T>，Task，或者Void，所以获取返回值只能await或者.Result,但是 async+await和async+.Result还是不一样的

             public async void RunAwaitTask()
            {
                Thread.Sleep(1000);
                Console.WriteLine(222);
                var ff=Task.Run(() =>
                {
                    Thread.Sleep(2000);
                    Console.WriteLine(444);
                    return 666;
                }).Result;
                Console.WriteLine(555);
                Console.WriteLine(ff);
                Console.WriteLine(777);
            }
          
        ######## 测试部分 ########
        TestTask tm = new TestTask();
        Console.WriteLine(111);
        tm.RunAwaitTask();
        Console.WriteLine(333);
       
        结果:
        111
        222       
        444
        555
        666
        777
        333
        可以看出关键点在于await
        不解释了
  

这只是最简单开始，还会有各种异步嵌套。但这个最基本的区别脑子里必须定下来，这样遇到各个的场景就能想版本应用和实现了，也能断定自己写的代码该怎么走了，。线程牵扯到各个线程按不同的时间段一起执行，谁先执行完，谁后执行完都会造成不同的结果。所有有了指导思想就可以慢慢诊断了