.Net进阶系列(11)-异步多线程(委托BeginInvoke)（被替换）

一. BeginInvoke最后两个参数的含义

　　倒数第二个参数：指该线程执行完毕后的回调函数；倒数第一个参数：可以向回调函数中传递参数。

     下面以一段代码说明：

        /// <summary>
        /// 执行动作:耗时而已
        /// </summary>
        private void TestThread(string threadName)
        {
            Console.WriteLine("线程开始：线程名为：{2}，当前线程的id为:{0}，当前时间为：{1},", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName);
            long sum = 0;
            for (int i = 1; i < 999999999; i++)
            {
                sum += i;
            }
            Console.WriteLine("线程结束：线程名为：{2}，当前线程的id为::{0}，当前时间为：{1}", System.Threading.Thread.CurrentThread.ManagedThreadId, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), threadName);
        }
 　　  private void button1_Click_1(object sender, EventArgs e)
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            Console.WriteLine("----------------- 二.委托的异步调用测试  --------------------------");
            Console.WriteLine("----------------- button1_Click 开始 主线程id为：{0}  --------------------------", Thread.CurrentThread.ManagedThreadId);

            #region 2. 异步回调和异步参数
            {
                Action<string> myFunc = this.TestThread;
                //参数说明：前面几个参数都是方法的参数值，倒数第二个为异步调用的回调函数，倒数第一个为传给回调函数的参数
                for (int i = 0; i < 5; i++)
                {
                    string name = string.Format("button1_Click{0}", i);
                    myFunc.BeginInvoke(name, t =>
                    {
                        Console.WriteLine("我是线程{0}的回调", Thread.CurrentThread.ManagedThreadId);
                        //用 t.AsyncState 来获取回调传进来的参数
                        Console.WriteLine("传进来的参数为：{0}", t.AsyncState);
                    }, "maru");
                }
            }
            #endregion

            watch.Stop();
            Console.WriteLine("----------------- button1_Click 结束 主线程id为：{0}  总耗时：{1}--------------------------", Thread.CurrentThread.ManagedThreadId, watch.ElapsedMilliseconds);
        }

　　结果：

二. 异步调用的三种书写

　  在上述代码中，我们发现BeginInvoke中，除了我们介绍的最后两个参数外，还有一个参数，传递进去了name，细心的人会发现，正式函数TestThread所需的参数，那么向函数中传递参数到底是在赋值委托时传递，还是委托调用时传递呢？

     答案是两者皆可，如果在函数赋值委托时候传递，那么委托调用的时候，BeginInvoke只有最后两个参数。如果在委托调用的时候传递，BeginInvoke除了最后两个参数外，函数本身有几个参数，BeginInvoke前面将多出几个参数位置。

        /// <summary>
        /// 两个参数
        /// </summary>
        public static void TestThread(string txt1, string txt2)
        {
            Console.WriteLine("线程开始：测试参数为：{0}和{1}，当前线程的id为:{2}", txt1, txt2, System.Threading.Thread.CurrentThread.ManagedThreadId);
            long sum = 0;
            for (int i = 1; i < 999999999; i++)
            {
                sum += i;
            }
            Console.WriteLine("线程结束：测试参数为：{0}和{1}，当前线程的id为:{2}", txt1, txt2, System.Threading.Thread.CurrentThread.ManagedThreadId);
        }
          //1. 方式一（使用多重载Action<>委托，函数的参数在BeginInvoke中传入）
            {
                Action<string, string> act = TestThread;
                IAsyncResult iTest = act.BeginInvoke("参数1", "参数2", t =>
                   {
                       Console.WriteLine("我是线程执行后的回调");
                       Console.WriteLine(t.AsyncState);

                   }, "我是传递参数的位置");
            }

            //2. 方式二（使用Action委托,将参数值直接写在方法中,则无须向BeginInvoke中传入）
            {
                Action act2 = () => TestThread("参数1", "参数2");
                act2.BeginInvoke(t =>
                {
                    Console.WriteLine("我是线程执行后的回调");
                    Console.WriteLine(t.AsyncState);

                }, "我是传递参数的位置");
            }

            //3. 方式三（下面两个等价，只不过是第一个省略{},在函数体中将方法写入）
            {
                Action<string, string> act3 = (a, b) => TestThread(a, b);
                //Action<string, string> act3 = (a, b) =>
                //{
                //    TestThread(a, b);
                //};
                IAsyncResult iTest = act3.BeginInvoke("参数1", "参数2", null, null);
            }

三. 线程等待的三种方式

   关于利用委托开启多线程，其线程等待有三种方式：endInvoke、waitone、IsCompleted，推荐使用endInvoke这种方式。

     private void button1_Click_1(object sender, EventArgs e)
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            Console.WriteLine("----------------- 二.委托的异步调用测试  --------------------------");
            Console.WriteLine("----------------- button1_Click 开始 主线程id为：{0}  --------------------------", Thread.CurrentThread.ManagedThreadId);

            #region 4. 异步等待
            {
                IAsyncResult asyncResult = null;
                Action<string> myFunc = this.TestThread;
                string name = string.Format("button1_Click{0}", 111);
                asyncResult = myFunc.BeginInvoke(name, t =>
                 {
                     Console.WriteLine("我是线程{0}的回调", Thread.CurrentThread.ManagedThreadId);
                     //用 t.AsyncState 来获取回调传进来的参数
                     Console.WriteLine("传进来的参数为：{0}", t.AsyncState);
                 }, "maru");

                //等待的方式1：会有时间上的误差
                //while (!asyncResult.IsCompleted)
                //{
                //    Console.WriteLine("正在等待中");
                //}

                // 等待的方式二:
                //asyncResult.AsyncWaitHandle.WaitOne();//一直等待
                //asyncResult.AsyncWaitHandle.WaitOne(-1);//一直等待
                //asyncResult.AsyncWaitHandle.WaitOne(1000);//等待1000毫秒，超时就不等待了

                //等待的方式三：
                myFunc.EndInvoke(asyncResult);


            }
            #endregion

            watch.Stop();
            Console.WriteLine("----------------- button1_Click 结束 主线程id为：{0}  总耗时：{1}--------------------------", Thread.CurrentThread.ManagedThreadId, watch.ElapsedMilliseconds);
        }
        #endregion

    运行上述代码，我们会发现，主界面又被卡在了，这正好印证了主线程在等待，结果如下：

   

四. 多个线程的等待

    上面介绍的是单个线程的等待，有三种方式，那么如果同时开启了多个线程，主线程需要等待这多个线程，这时需要自己写循环，来进行线程等待。

            {
                List<IAsyncResult> list = new List<IAsyncResult>();
                for (int i = 0; i < 5; i++)
                {
                    string name1 = string.Format("ypf1-{0}", i);
                    string name2 = string.Format("ypf2-{0}", i);
                    Action act = () => TestThread(name1, name2);
                    IAsyncResult ir = act.BeginInvoke(null, null);
                    list.Add(ir);
                }
                //利用委托进行的异步多线程,采用上述方式二的等待最合理的
                //缺点：整体上需要写循环，麻烦
                foreach (var item in list)
                {
                    item.AsyncWaitHandle.WaitOne();
                }
            }