1、进程的同步和异步

  1.1 进程同步

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

  1.2 异步

2、线程执行方法

  2.1 调用线程时传递参数

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);
    }    
} 

   2.2.2 使用回调方式返回结果

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); //异步执行方法
    }

}

结语

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

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

【.NET线程--进阶（二）】--小问题？不简单……