C#--委托开启线程

以下是学习笔记

1，要执行的方法

        static int  Test(int i,string str)//定义一个函数，返回值int类型
        {
            Console.WriteLine("test"+ "-" + i +"-"+str+"-线程ID："+ Thread.CurrentThread.ManagedThreadId.ToString());
            Thread.Sleep(100);//让当前线程休眠，暂停当前的线程，单位ms
            return 100;
        }

　　

2，【测试1】检测线程的结束，线程结束了才能取得返回值

        static void Test1()
        {
            //1，通过委托，开启一个线程
            Func<int, string, int> a = Test;
            IAsyncResult ar = a.BeginInvoke(1, "siki", null, null);//开启一个新的线程去执行a所引用的方法
            //1 和"siki"，是传参数
            //IAsyncResult获取当前线程的状态
            //可以认为线程是同时执行的（异步执行）

            #region 【测试1】检测线程的结束，线程结束了才能取得返回值

            while (ar.IsCompleted == false)//如果当前线程没有执行完毕
            {
                Console.WriteLine($"等待开启的线程执行完成，线程ID：{Thread.CurrentThread.ManagedThreadId.ToString()}");
                Thread.Sleep(10);//控制子线程的检测频率
            }

            int res = a.EndInvoke(ar);//获取线程的返回值
            Console.WriteLine($"开启的线程执行完成，线程ID：{Thread.CurrentThread.ManagedThreadId.ToString()}，得到返回值：{res}");

            #endregion
        }

　　

Main方法运行：

            Console.WriteLine($"主线程开始：线程ID：{Thread.CurrentThread.ManagedThreadId.ToString()}");
            Test1();

　

运行结果：

主线程开始：线程ID：1
等待开启的线程执行完成，线程ID：1
test-1-siki-线程ID：3
等待开启的线程执行完成，线程ID：1
等待开启的线程执行完成，线程ID：1
等待开启的线程执行完成，线程ID：1
等待开启的线程执行完成，线程ID：1
等待开启的线程执行完成，线程ID：1
等待开启的线程执行完成，线程ID：1
等待开启的线程执行完成，线程ID：1
等待开启的线程执行完成，线程ID：1
等待开启的线程执行完成，线程ID：1
开启的线程执行完成，线程ID：1，得到返回值：100

　　

3，【测试2】，通过等待句柄，检测线程结束

        static void Test2()
        {
            //1，通过委托，开启一个线程
            Func<int, string, int> a = Test;
            IAsyncResult ar = a.BeginInvoke(1, "siki", null, null);//开启一个新的线程去执行a所引用的方法
            //1 和"siki"，是传参数
            //IAsyncResult获取当前线程的状态
            //可以认为线程是同时执行的（异步执行）

            //【测试2】，通过等待句柄，检测线程结束 
            bool isEnd = ar.AsyncWaitHandle.WaitOne(90);//1000ms表示超时时间，如果等待了1000ms，线程还没结束，这个方法返回false
            if (isEnd)
            {
                int res = a.EndInvoke(ar);//获取线程的返回值 
                Console.WriteLine($"结束了,得到了返回值是：{res},线程ID：{Thread.CurrentThread.ManagedThreadId.ToString()}");
            }
            else
            {
                Console.WriteLine($"没结束,等待继续执行,线程ID：{Thread.CurrentThread.ManagedThreadId.ToString()}");
                int res = a.EndInvoke(ar);//获取线程的返回值
                Console.WriteLine($"结束了,得到了返回值是：{res},线程ID：{Thread.CurrentThread.ManagedThreadId.ToString()}");
            }
        }

　　

Main方法运行：

            Console.WriteLine($"主线程开始：线程ID：{Thread.CurrentThread.ManagedThreadId.ToString()}");
            //Test1();
            Test2();

　　

运行结果：

主线程开始：线程ID：1
test-1-siki-线程ID：3
没结束,等待继续执行,线程ID：1
结束了,得到了返回值是：100,线程ID：1

　　

4，【测试3】通过回调，检测委托的线程结束

        static void Test3()
        {
            //【测试3】通过回调，检测委托的线程结束
            Func<int, string, int> a3 = Test;
            IAsyncResult ar3 = a3.BeginInvoke(1, "siki", OnCallBack, a3);//倒数第二个参数是一个委托类型的参数，表示回调函数，就是当线程结束的时候会调用这个委托指向的方法
            //倒数第一个参数用来给回调函数传递参数

            //【测试3】改成lambda表达式
            //Func<int, string, int> a = Test;
            //a.BeginInvoke(1, "siki", ar =>
            //{
            //    int res = a.EndInvoke(ar);
            //    Console.WriteLine("在lmabda中得到了返回值是：" + res);

            //}, null);
        }

　　

回调方法：

        static void OnCallBack(IAsyncResult ar)
        {
            Func<int, string, int> a3 = ar.AsyncState as Func<int, string, int>;
            //ar.AsyncState就是传递过来的数据
            //ar.AsyncState是这个 Func<int, string, int>类型的
            //把ar.AsyncState转成这个类型的 Func<int, string, int>的对象

            int res = a3.EndInvoke(ar);//获取线程的返回值 
            Console.WriteLine("在回调函数中得到了返回值是：" + res);
        }

　　

Main方法运行：

        static void Main(string[] args)
        {
            Console.WriteLine($"主线程开始：线程ID：{Thread.CurrentThread.ManagedThreadId.ToString()}");
            //Test1();
            //Test2();
            Test3();

            Console.ReadKey();
        }

　　

测试结果：

主线程开始：线程ID：1
test-1-siki-线程ID：3
在回调函数中得到了返回值是：100