2017-01-02-检测委托线程结束-通过等待句柄和回调函数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace _2016_12_29_罗斯_线程
{
    class Program
    {
        //一般来说，程序执行都是从上而下，打印顺序应该是先打印Tes1这个上面的方法再打印下面的Main方法
        //然而启用了线程后，打印出的文字顺序则变成了Main的文字出现在第一行，Test1在第二行
        //事实上，启用了线程后，cpu从两者中随机调用，并不存在谁先谁后一说

        //1.声明一个普通无参数无返回值的方法Test1
        static void Test1()
        {
            Console.WriteLine("无返回值无参数普通方法程序执行啦！");
        }

        //4.无返回值有传递参数的方法
        static void Test2(int i,string str)
        {
            Console.WriteLine("无返回值有参数的"+i+"XX"+"的普通方法程序开始啦！");
        }

        //7.有返回值有参数的方法
        static int Test3(int t, string str)//12.为了模拟耗时操作，在return前输入Thread.Sleep(100);
        {
            Console.WriteLine("有返回值，有参数的" + t +"XX"+ "的普通方法程序开始啦！");
            Thread.Sleep(100);
            //13.Thread是在using System.Threading;里的，所以命名空间没有的话需要补写using System.Threading;
            //Thread.Sleep让当前线程休眠（暂停线程的执行），单位是毫秒：ms，100ms相当于0.1秒

            return 100;
        }
        


        static void Main(string[] args)//在main线程中执行
        //一个线程里面语句的执行是从上到下的！
        {
            //2.通过声明一个委托去开启一个线程
            //Action a = Test1;

            //5.相应的委托类型及委托变量之间要添加泛型尖括号，里面填方法对应的类型
            //Action<int,string> b = Test2;

            //3.用委托的变量名.BeginInvoke方法，开启一个新的线程，去执行变量a所引用的方法Test1 
            //a.BeginInvoke(null, null);//括号里的2个参数暂时用null空值代替


            //6.传参数
            //b.BeginInvoke(100,"罗斯",null, null);

            //可以认为线程是同时执行的，也就是异步执行或者并行
            //Console.WriteLine("Main开启线程的方法启动啦！快看我跟普通方法是不是一起出现~！");

            //8.由于有返回值类型，所以只能用Func委托
            //Func<int, string, int> c = Test3;
            //c.BeginInvoke(100, "XX", null, null);

            //10.c.BeginInvoke(100, "XX", null, null)有个返回值是IAsyncResult类型的
            //IAsyncResult ar = c.BeginInvoke(100, "XX", null, null);
            //IAsyncResult 可以取得当前线程的状态

            //假设此时Test3运行时间较长，这里则不会立即获得返回值。
            //一般我们会为比较耗时间的操作，开启单独的线程去执行：比如下载操作（Test3），下载完之后需要获得文件路径（return）什么的


            #region 判断线程结束的第一种方法
            //想要获取线程的返回值，首先要判断这个线程是否执行结束，结束即可得。

            //9-1.想要在Main方法里获取返回值，则首先要建立一个死循环做一个判断。
            //while (ar.IsCompleted == false)//11.变量ar有个“是否完毕”的属性IsCompleted，如果当前线程没有执行完毕（false）
            //{
            //    //12-1.如果没完毕，则输出字符串
            //    Console.WriteLine("程序仍在执行中......");
                
            //    //16-1.也可以让此线程暂停10ms，可以减少字符串的输出，也就是每10ms检测一次，控制子线程的检测有没有结束的频率
            //    Thread.Sleep(10);

            //}
            //14-1.当跳出while死循环，程序执行完毕，我们就可以取得Test3的执行结果
            //而Test3的结果是通过委托c（Func c）去调用的，所以可以通过c去取得结果
            //且c的线程状态是用过IAsyncResult ar去取得的
            //所以用c.EndInvoke方法，且把线程状态的变量结果ar传递过去
            //再用int res去接收这个返回值(因为Test3里return的是100，所以用int)，即取得异步线程的返回值
            //int res = c.EndInvoke(ar);

            //15-1.输出返回值
            //Console.WriteLine(res);

            #endregion

            #region  检测线程结束的第二个方法，用到AsyncWaitHandle等待句柄
            ////9-2.检测线程结束的第二个方法
            ////ar有个属性AsyncWaitHandle（等待句柄，可以通过等待句柄的WaitOne方法等待当前线程执行完毕，再执行后面的代码。
            ////WaitOne（）括号里的参数是一个超时时间，等待了这个参数时间之后，线程还没执行完，则返回false，否则返回true。
            ////所以用bool加变量名去接收这个布尔结果。这里设置超时时间为1000毫秒
            //bool isEnd = ar.AsyncWaitHandle.WaitOne(1000);
            ////超时时间即使设置了1000ms，实际等待的时间根据线程决定的，例如现在100ms，实际则等待了100ms，如果超过了1000ms，则还是等待了1000ms
            ////即等待时间设置了1000ms的话，实际等待时间肯定<=1000ms


            ////10-2.通过isEnd判断有没有结束，首先预估一下是否在超时时间内结束,因为Func c的运行时间是100ms，所以现在设置的超时时间为1000ms是足够的。
            //if (isEnd)
            //{
            //    int res = c.EndInvoke(ar);//如果结束则取得return的结果100 
            //    Console.WriteLine(res);
            //}

            #endregion

            #region 通过回调，检测线程结束（最常用的方法）
            //9-3
            Func<int, string, int> c = Test3;//声明一个委托，指向方法Test3，通过BeginInvoke传递参数且开启线程           
            
            //IAsyncResult ar = c.BeginInvoke(100, "XX", null, null);
            //第一个null是用来传递委托类型的，传递的是一个方法，这个方法是当IAsyncResult ar这个方法结束之后才会调用的方法10-3。
            //第二个null是给回调函数传递参数用的
            IAsyncResult ar = c.BeginInvoke(100, "XX", OnCallBack, c);
            //也就是，右二参数是一个委托类型的参数，表示回调函数。就是当线程结束的时候回调用这个委托指向的方法。
            //也就是，右一参数是用来给回调函数传递数据
            
            Console.ReadKey();
            
        }
            //10-3声明一个方法
        static void OnCallBack(IAsyncResult ar)
        { 
            //怎么通过回调，取得一个方法的返回值：
            //首先要拿到这个委托类型Func c,调用c里面的EndInvoke方法       

            Func<int,string,int> c = ar.AsyncState as Func<int, string, int>;
            int res = c.EndInvoke(ar);
            Console.WriteLine("在回调函数中取得结果");
        }

    
             #endregion 
    }
}

回调函数的另一种写法：Lambda表达式更简单

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace _2016_12_29_罗斯_线程
{
    class Program
    {
       static void Main(string[] args)
       { Func<int, string, int> c = Test3;
            //Lambda表达式,可以直接访问外部变量c,所以不需要传递任何参数，所以倒数第一个参数为空null
            c.BeginInvoke(100, "XX", ar =>
            {
                int res = c.EndInvoke(ar);
                Console.WriteLine(res+"在lambada表达式中取得");

            },null);
            
            Console.ReadKey();
       }
            
      
            //10-3声明一个方法
        static void OnCallBack(IAsyncResult ar)
        { 
            //怎么通过回调，取得一个方法的返回值：
            //首先要拿到这个委托类型Func c,调用c里面的EndInvoke方法       

            Func<int,string,int> c = ar.AsyncState as Func<int, string, int>;
            int res = c.EndInvoke(ar);
            Console.WriteLine("在回调函数中取得结果");
        }
   
    }
}