上篇博客对线程的基本方法进行了解析，并使用了两个实例来演示了线程方法的使用，在前几篇博客中有很多小问题没有详细说明，比如进程的同步异步问题，线程执行时参数的传递和获取参数等等，该篇博客将会针对这些小问题来展开讨论。

1、进程的同步和异步

      

  1.1 进程同步

       就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是必须一件一件事做，等前一件做完了才能做下一件事。就像早上起床后，先洗涮,然后才能吃饭，不能在洗涮没有完成时，就开始吃饭。按照这个定义，其实绝大多数函数都是同步调用。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。

       最常见的例子就是MessageBox。该函数发送一个消息给某个窗口，在对方处理完消息之前，这个函数不返回。当对方处理完毕以后，该函数才把消息处理函数所返回的result值返回给调用者。

  1.2 异步

       异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。
       以多线程为例，在运行一个程序时会把CPU分成多个线程来运行程序，这些互不影响的线程在同一时间运行实现了异步执行。
      

2、线程执行方法

  2.1 调用线程时传递参数

        细心的童鞋应该能够发现前篇博客在创建线程时传递给线程的参数使用的是ThreadStart委托，而且给线程执行的方法并没有参数，这样在调用时就不用关心传递参数的问题。其实.NET为我们提供了两种线程委托，一个是ThreadStart委托，在执行时不需要使用参数，另外一个是ParameterizedThreadStart委托，从它的字面意思上可以读出它是参数化的委托，也就是说使用该种委托将会能够为线程函数传递参数。也就是说 ParameterizedThreadStart 委托提供了一种简便方法，可以在调用 Thread.Start 方法重载时将包含数据的对象传递给线程。代码如下：

class Program
{
    static void Main(string[] args)
    {
        
            //使用ParameterizedThreadStart委托调用有参数的方法
            Thread th = new Thread(new ParameterizedThreadStart(PrintToScreen.PrintString));
            th.Start("This is parameterized thread.");  //在Start方法中为方法执行参数
    }
}

/// <summary>
/// 需要执行的打印文字的类
/// </summary>
class PrintToScreen {
    /// <summary>
    /// 执行打印字符串的线程方法
    /// </summary>
    /// <param name="str">需要打印的字符串</param>
    public static void PrintString(object str) {
        Console.Write(str); //向控制台打印字符串
        Console.Read(); 
    }
}

运行结果：

        上面使用 ParameterizedThreadStart 委托传递数据，但该方法并不安全，因为 Thread.Start 方法重载接受任何对象。一种替代方法是将线程过程和数据封装在帮助器类中，并使用 ThreadStart 委托执行线程过程，如下的代码示例：

class Program
{
    static void Main(string[] args)
    {
        PrintToScreen pts = new PrintToScreen("This is parameterized thread.",4);
        //使用ThreadStart委托调用有参数的方法
        Thread th = new Thread(pts.PrintString);
        th.Start();  //在Start方法中为方法执行参数

    }
}

/// <summary>
/// 需要执行的打印文字的类
/// </summary>
class PrintToScreen {
    private string str; //需要打印的字符串
    private int j;  //需要打印字符串的个数

    /// <summary>
    /// 构造函数制定类参数
    /// </summary>
    /// <param name="str">需要打印的字符串</param>
    /// <param name="j">打印次数</param>
    public PrintToScreen(string str, int j) {
        this.str = str;
        this.j = j;
    }
    /// <summary>
    /// 执行打印字符串的线程方法
    /// </summary>
    public void PrintString() {

        for (int i = 0; i < j; ++i)
        {
            Console.WriteLine(i.ToString()+" "+str); //向控制台打印字符串
        }
        Console.Read();
    }
}

运行结果：

 2.2 执行线程后获取返回值

  2.2.1 IAsyncResult+EndInvoke

         在.NET中使用线程的方法很多，使用委托的BeginInvoke和EndInvoke方法就是其中之一。BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用，下面我们介绍两种方法从EndInvoke中获取返回值。

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading;  
     
namespace MyThread  
{  
    class Program
    {
	    static void Main(string[] args)
	{
	
	    NewDelegate nd = NewTask;   //声明委托，并为委托指定方法
	    IAsyncResult asyncresult = nd.BeginInvoke(2000, null, null);  //执行委托，并获取异步操作的状态
	        
	    //while循环，判断异步操作是否完成，没有完成的话将会打印*表示提醒用户等待
	    while (!asyncresult.IsCompleted) {
	        Console.Write("*");
	        Thread.Sleep(100);
	    }
	
	    //调用EndInvoke获取返回值
	    int result = nd.EndInvoke(asyncresult);
	    Console.Write(result);
	    Console.Read();
	
	}
	
	    /// <summary>
	    /// 获取随机数
	    /// </summary>
	    /// <param name="intTime">方法的参数，执行的时间值</param>
	    /// <returns>int 返回不大于1000的随机整数</returns>
	    public static int NewTask(int intTime) {
	        Console.WriteLine("Starting the task！");
	        Thread.Sleep(intTime);//线程停顿1000秒
	        Random rand = new Random(); //创建一个随机数生成器
	        int n = rand.Next(1000);    //获取一个随机数
	        Console.WriteLine("The task is completed!");
	        return n;   //返回随机数
	    }
	
	    /// <summary>
	    /// 委托，指定执行的方法
	    /// </summary>
	    /// <param name="intTime">方法的参数，执行的时间值</param>
	    /// <returns>int类型</returns>
	    private delegate int NewDelegate(int intTime);
    }    
} 

        在运行上面的程序后，由于newTask方法通过Sleep延迟了2秒，因此，程序直到2秒后才输出最终结果（一个随机整数）。如果不调用EndInvoke方法，程序会立即退出，这是由于使用BeginInvoke创建的线程都是后台线程，这种线程一但所有的前台线程都退出后（其中主线程就是一个前台线程），不管后台线程是否执行完毕，都会结束线程，并退出程序。关于前台和后台线程的详细内容，将在后面的部分讲解。

   2.2.2 使用回调方式返回结果

       上面介绍的方法虽然可以成功返回结果，也可以给用户一些提示，但在这个过程中，整个程序就象死了一样，要想在调用的过程中，程序仍然可以正常做其它的工作，就必须使用异步调用的方式。下面我们使用GUI程序来编写一个例子。
       下面的代码通过异步的方式访问的form上的一个textbox，因此，需要按ctrl+f5运行程序。并在form上放一些其他的可视控件，然在点击button1后，其它的控件仍然可以使用，就象什么事都没有发生过一样，在10秒后，在textbox1中将输出100。
       Note：不能直接按F5运行程序，否则无法在其他线程中访问这个textbox，关于如果在其他线程中访问GUI组件，前篇博客中已经提到。

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private delegate int MyMethod();   //声明委托执行的方法类型

    /// <summary>
    /// 获取返回值
    /// </summary>
    /// <returns>int 获取小于1000的随机整数</returns>
    private int method()
    {
        Thread.Sleep(10000);    //线程停顿10秒后向返回值
        Random rand = new Random(); //创建随机数生成器
        int j = rand.Next(1000);    //获取小于1000的随机数
        return j;   //返回该随机数
    }

    /// <summary>
    /// 异步执行的回调函数
    /// </summary>
    /// <param name="asyncResult">异步操作的状态</param>
    private void MethodCompleted(IAsyncResult asyncResult)
    {
        if (asyncResult == null)
        {
            return;
        }

        //执行函数，获取返回值
        textBox1.Text = (asyncResult.AsyncState as MyMethod).EndInvoke(asyncResult).ToString();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        MyMethod my = method;   //声明委托并为委托指定执行方法
        IAsyncResult asyncResult = my.BeginInvoke(MethodCompleted, my); //异步执行方法
    }

}

         对于BeginInvoke方法，它有多种重载方式，这里用的是它的两个参数重载。第一个参数是回调方法委托类型，这个委托只有一个参数，就是IAsyncResult，如MethodCompleted方法所示。当method方法执行完后，系统会自动调用MethodCompleted方法。BeginInvoke的第二个参数需要向MethodCompleted方法中传递一些值，一般可以传递被调用方法的委托，如上面代码中的my。这个值可以使用IAsyncResult.AsyncState属性获得。

结语

       上面提到执行部件和调用者通过三种途径返回结果：状态、通知和回调。可以使用哪一种依赖于执行部件的实现，除非执行部件提供多种选择，否则不受调用者控制。如果执行部件用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一种很严重的错误）。如果是使用通知的方式，效率则很高，因为执行部件几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。

        看似简单的小问题实则有很多注意项，为了能达到优化和安全的目的，小问题也不简单。