.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 = ;
             for (int i = ; i < ; 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 = ; i < ; 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 = ;
             for (int i = ; i < ; 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}", );
                 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 = ; i < ; 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();
                 }
             }