异步编程VS同步编程

案例一：

总结

相关总结放代码里面了，这样更容易理解。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace AsyncDemo
{
    public partial class FrmTest : Form
    {
        public FrmTest()
        {
            InitializeComponent();
        }
        //同步编程
        private void btnTest1_Click(object sender, EventArgs e)
        {
            this.lblInfo1.Text = ExecuteTask1(10).ToString();

            //中间任务计算...
            this.lblInfo2.Text = ExecuteTask2(20).ToString();
        }

        //【3】异步调用
        private void btnTest2_Click(object sender, EventArgs e)
        {

            MyCalculator objMyCal = ExecuteTask1;  //定义一委托变量，并引用对应的方法Calculator1

            //通过委托异步调用方法Calculator1
            //委托类型的Begininvoke（<输入和输出变量>,AsyncCallbac callback,object asyncState）方法：异步调用的核心   
            //第一个参数10，表示委托对应的方法实参。
            //第二个参数callback，回调函数，表示异步调用结束时自动调用的函数。
            //第三个参数asyncState，用于向回调函数提供相关参数信息
            //返回值：IAsyncResult -->异步操作状态接口，封装了异步执行的中的参数
            //IAsyncResult接口成员：查看帮助文档

            //1.异步调用任务
            IAsyncResult result = objMyCal.BeginInvoke(10, null, null);
            this.lblInfo1.Text = "正在计算请稍等...";

            //2.可以并行执行的其他任务...
            this.lblInfo2.Text = ExecuteTask2(20).ToString();

            //3.获取异步执行结果
            int r = objMyCal.EndInvoke(result);
            //委托类型的EndInvoke（）方法：借助于IAsyncResult接口对象，不断查询异步调用是否结束。
            //该方法知道被异步调用的方法所有参数，所有，异步调用完毕后，取出异步调用结果作为返回值。
            this.lblInfo1.Text = r.ToString();

        }

        //【2】根据委托实现方法
        private int ExecuteTask1(int num)
        {
            System.Threading.Thread.Sleep(5000);//延迟5秒...
            return num * num;
        }
        private int ExecuteTask2(int num)
        {
            return num * num;
        }

        //【1】定义一个委托
        public delegate int MyCalculator(int num);

     
    }
}

案例二：

 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace _02_AsyncCallBackDemo
{
    public partial class FrmCalllBack : Form
    {
        public FrmCalllBack()
        {
            InitializeComponent();

            //【3】初始化委托变量
            this.objMyCal = new MyCalculator(ExecuteTask);

            //也可以直接使用Lambda表达式
            this.objMyCal = (num, ms) =>
                {
                    System.Threading.Thread.Sleep(ms);
                    return num * num;
                };
        }
        //【3】创建委托变量（因为异步函数和回调函数都要用，所以定义成员变量）
        private MyCalculator objMyCal = null;

        //【1】声明一个委托
        public delegate int MyCalculator(int num, int ms);

        /// <summary>
        /// 【2】根据委托定义一个方法：返回一个数的平方
        /// </summary>
        /// <param name="num">基数</param>
        /// <param name="ms">延迟的时间：秒</param>
        /// <returns></returns>
        private int ExecuteTask(int num, int ms)
        {
            System.Threading.Thread.Sleep(ms);
            return num * num;
        }

        //【4】同时执行多个任务
        private void btnExec_Click(object sender, EventArgs e)
        {
            for (int i = 1; i < 11; i++)//产生10个任务
            {
                //开始异步执行，并封装回调函数 objMyCal.BeginInvoke(10 * i, 1000 * i, null, i);
                objMyCal.BeginInvoke(10 * i, 1000 * i, MyCallBack, i);
                //最后一个参数 i 给回调函数的字段AsyncState赋值，如果数据很多可以定义成类或结构
            }
        }
        //【5】回调函数
        private void MyCallBack(IAsyncResult result)
        {
            int res = objMyCal.EndInvoke(result);

            //异步显示结果：result.AsyncState字段用来封装回调时自定义的参数，object类型
            Console.WriteLine("第{0}个计算结果为：{1}", result.AsyncState.ToString(), res);
        }
    }
    //异步编程总结：
    //1. 异步编程是建立在委托基础上的一种编程方法。
    //2. 异步调用的每个方法都是在独立的线程中执行。因此，本质上就是一种多线程程序，也可以说是一种“简化版本”的多线程技术。
    //3. 比较适合在后台运行较为耗费时间的《简单任务》，并且任务要求相互独立，任务中不应该有代码直接访问可视化控件。
    //4. 如果后台任务要求必须按照特定顺序执行，或者必须访问共享资源，则异步编程不适合，而应该直接采用多线程开发技术。

}

案例三：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Threading;

namespace _03_ThreadTest
{
    /*
     * 进程：一个正在运行的程序就是一个进程。操作系统根据进程分配各种资源（内存...）
     * 线程：操作系统为了提高效率会将一个进程分成多个线程，并按照线程来分配CPU执行的时间。
     * 时间分配：比如A进程10个线程，Ｂ进程2个线程，操作系统会按照12个线程来分配CPU时间，这样A进程有机会获得CPU的几率就大。
     * 线程特点：在具有多个CPU的计算机中，可以并行执行。如果是单CPU，则会出现《假象》。
     * 单线程：只有一个线程的进程称为“单线程”进程。拥有多个线程的的进程称为多线程进程。
     * Thread类：表示托管线程，每个Thread对象都代表这一个托管线程，每个托管线程都对应这一个函数。
     * 
     * 
     * Thread类：与操作系统真是的本地线程不是一一对应关系，它只是一个“逻辑线程”。
     * ProcessThread类：用于表示操作系统中真实的本地线程。
     */
    public partial class FrmThead : Form
    {
        public FrmThead()
        {
            InitializeComponent();
        }
        //执行任务1
        private void btnExecute1_Click(object sender, EventArgs e)
        {
            int a = 0;
            //  ThreadStart()方法的定义：     public delegate void ThreadStart()
            Thread objThread1 = new Thread(delegate()
             {
                 for (int i = 1; i <= 20; i++)
                 {
                     Console.Write((a + i) + "  ");
                     Thread.Sleep(500);
                 }
             });

            //Thread objThread1 = new Thread(() =>
            //{
            //    for (int i = 1; i <= 20; i++)
            //    {
            //        Console.Write((a + i) + "  ");
            //        Thread.Sleep(500);
            //    }
            //});

            objThread1.IsBackground = true;//设置为后台线程（通常都要这样设置）
            objThread1.Start();
        }
        //执行任务2
        private void btnExecute2_Click(object sender, EventArgs e)
        {
            Thread objThread2 = new Thread(() =>
            {
                for (int i = 1; i <= 50; i++)
                {
                    Console.WriteLine("-------a" + i + "-------  ");
                    Thread.Sleep(100);
                }
            });
            objThread2.IsBackground = true;
            objThread2.Start();
        }
    }
}