就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是必须一件一件事做，等前一件做完了才能做下一件事。就像早上起床后，先洗涮,然后才能吃饭，不能在洗涮没有完成时，就开始吃饭。按照这个定义，其实绝大多数函数都是同步调用。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。
最常见的例子就是MessageBox。该函数发送一个消息给某个窗口，在对方处理完消息之前，这个函数不返回。当对方处理完毕以后，该函数才把消息处理函数所返回的result值返回给调用者。
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();
}
}
在.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);
}
} 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); //异步执行方法
}
}
上面提到执行部件和调用者通过三种途径返回结果：状态、通知和回调。可以使用哪一种依赖于执行部件的实现，除非执行部件提供多种选择，否则不受调用者控制。如果执行部件用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一种很严重的错误）。如果是使用通知的方式，效率则很高，因为执行部件几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。
看似简单的小问题实则有很多注意项，为了能达到优化和安全的目的，小问题也不简单。
原文：http://blog.csdn.net/zhang_xinxiu/article/details/19151145