此篇文章简单总结了C#中主要的多线程实现方法，包括Thread、ThreadPool、Parallel和Task类，以及BackgroundWorker控件的主要接口和用法。如有误，请指正。
一、进程和线程
进程是CPU资源分配的最小单位，线程是CPU调度的最小单位。可以理解为，打开一个应用程序时，操作系统启动一个进程，为其分配虚拟内存、文件句柄等资源，一个进程至少拥有一个线程，这些线程共享该进程的资源（内存和堆），但是每个线程都有独立的栈，以记录函数的执行位置和局部变量。CPU对线程的调度可以实现任务的并行执行，提高程序的运行效率。
二、在C#中使用多线程
1. Thread类
使用Thread类通过ThreadStart（无参数）或ParameterizedThreadStart（一个输入参数）类型的委托创建一个Thread对象，开启一个新线程，执行该委托传递的任务，此时线程尚未处于运行状态。调用Start()函数启动线程，当前线程继续执行。调用Join()函数可以阻塞当前线程，直到调用Join()的线程终止。
Thread类创建的线程默认为前台线程，可以通过IsBackground属性设置其为前台或后台线程。还可以通过Priority属性设置线程的优先级。
如需中止线程，调用Abort()方法，在调用该方法的线程上抛出ThreadAbortException异常，以结束该线程。线程内部可以通过try catch捕获该异常，在catch模块中进行一些必要的处理，如释放持有的锁和文件资源等，还可以通过Thread.ResetAbort()方法阻止线程的中止。但是通常来说，应当慎重使用Abort()方法，如果在当前线程中抛出该异常，其结果是可预测的，但是对于其他线程，它会中断任何正在执行的代码，有可能中断静态对象的生成，造成不可预测的结果。
using System;
using System.Threading;
namespace ConsoleApplication1
{
public class ThreadExample
{
public static void Main()
{
Thread thread = new Thread(new ThreadStart(DoWork));
thread.Start();
//thread.Join();
Thread.Sleep(10);
thread.Abort();
Thread parameterizedThread = new Thread(new ParameterizedThreadStart(DoWorkWithParam));
parameterizedThread.Start("test");
Console.ReadKey();
}
public static void DoWork()
{
try
{
for (int i = 0; i < 10000; i++)
Console.WriteLine("Work thread:" + i.ToString());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Thread.ResetAbort();
}
Console.WriteLine("Work thread: still alive and working.");
Thread.Sleep(1000);
Console.WriteLine("Work thread: finished working.");
}
public static void DoWorkWithParam(object obj)
{
string msg = (string)obj;
Console.WriteLine("Parameterized Work thread:" + msg);
}
}
}
2. 线程池
ThreadPool类维护一个线程的列表，提供给用户以执行不同的小任务，减少频繁创建线程的开销。ThreadPool的使用比较简单，只需调用ThreadPool.QueueUserWorkItem()方法，传递一个WaitCallback类型的委托，线程池即从池中选择一个线程执行该任务。
public static void Main()
{
for (int i = 0; i < 5; ++i)
ThreadPool.QueueUserWorkItem(DoWork);
Console.ReadKey();
}
public static void DoWork(Object o)
{
for (int i = 0; i < 3; i++)
Console.WriteLine("loop:{0}, thread id: {1}", i, Thread.CurrentThread.ManagedThreadId);
}
但是线程池的使用也有一些限制：
- 线程池中的线程均为后台线程，并且不能修改为前台线程
- 不能给入池的线程设置优先级或名称
- 对于COM对象，入池的所有线程都是多线程单元（MTA）线程，许多COM对象都需要单线程单元（STA） 线程
- 入池的线程只适合时间较短的任务，如果线程需要长时间运行，应使用Thread类创建线程或使用Task的LongRunning选项
3. Parallel类
Parallel和Task类都位于System.Threading.Task命名空间中，是对Thread和ThreadPool类更高级的抽象。Parrallel类有For()、ForEach()、Invoke()三个方法，前两者在每次迭代中调用相同的代码，实现了数据并行性，Invoke()允许同时调用不同的方法，实现任务并行性。
For()和ForEach()两者的用法类似。如下例，调用Parallel.For()方法，实现从0到10的迭代，每次迭代是并行执行的，并且从输出结果可以看出，执行顺序是不能保证的。
public static void Main()
{
ParallelLoopResult result = Parallel.For(0, 10, i =>
{
Console.WriteLine("i:{0}, thread id: {1}", i, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(10);
});
Console.WriteLine("Is completed: {0}", result.IsCompleted);
//i: 0, thread id: 9
//i: 2, thread id: 10
//i: 1, thread id: 9
//i: 3, thread id: 10
//i: 4, thread id: 9
//i: 6, thread id: 11
//i: 7, thread id: 10
//i: 5, thread id: 9
//i: 8, thread id: 12
//i: 9, thread id: 11
//Is completed: True
Console.ReadKey();
}
通过ParallelLoopState的Break()或Stop()方法，可以提前中断Parallel.For()的迭代。
public static void Main()
{
ParallelLoopResult result = Parallel.For(0, 100, (i, state) =>
{
Console.WriteLine("i:{0}, thread id: {1}", i, Thread.CurrentThread.ManagedThreadId);
if (i > 10)
state.Break();
Thread.Sleep(10);
});
Console.WriteLine("Is completed: {0}", result.IsCompleted);
Console.WriteLine("Lowest break iteration: {0}", result.LowestBreakIteration);
//i: 0, thread id: 10
//i: 25, thread id: 6
//i: 1, thread id: 10
//i: 2, thread id: 10
//i: 3, thread id: 10
//i: 4, thread id: 10
//i: 5, thread id: 10
//i: 6, thread id: 10
//i: 7, thread id: 10
//i: 8, thread id: 10
//i: 9, thread id: 10
//i: 10, thread id: 10
//i: 11, thread id: 10
//Is completed: False
//Lowest break iteration: 11
Console.ReadKey();
}
如需同时执行多个不同的任务，可以使用Parallel.Invoke()方法，它允许传递一个Action委托数组。
public static void Main()
{
Parallel.Invoke(Func1, Func2, Func3);
Console.ReadKey();
}
4. Task类
相比于Thread类，Task类为控制线程提供了更大的灵活性。Task类可以获取线程的返回值，也可以定义连续的任务——在一个任务结束结束后开启下一个任务，还可以在层次结构中安排任务，在父任务中可以创建子任务，这样就创建了一种依赖关系，如果父任务被取消，子任务也随之取消。Task类默认使用线程池中的线程，如果该任务需长期运行，应使用TaskCreationOptions.LongRunning属性告诉任务管理器创建一个新的线程，而不是使用线程池中的线程。
启动任务
以下程序演示了几种通过Task类启动任务的方式：
public class ThreadExample
{
public static void Main()
{
TaskFactory tf = new TaskFactory();
Task t1 = tf.StartNew(TaskMethod.DoTask, "using a task factory");
Task t2 = Task.Factory.StartNew(TaskMethod.DoTask, "factory via a task");
Task t3 = new Task(TaskMethod.DoTask, "using a task constructor and start");
t3.Start();
//需要.NetFramework 4.5以上
var t4 = Task.Run(() => TaskMethod.DoTask("using Run method"));
Console.ReadKey();
}
class TaskMethod
{
static object taskLock = new object();
public static void DoTask(object msg)
{
lock (taskLock)
{
Console.WriteLine(msg);
Console.WriteLine("Task id:{0}, Thread id :{1}",
Task.CurrentId == null ? "no task" : Task.CurrentId.ToString(),
Thread.CurrentThread.ManagedThreadId);
}
}
}
接收任务的返回值
对于任务有返回值的情况，可使用Task<TResult>泛型类，TResult定义了返回值的类型，以下代码演示了调用返回int值的任务的方法。
public static void Main()
{
var t5 = new Task<int>(TaskWithResult, Tuple.Create<int, int>(1, 2));
t5.Start();
t5.Wait();
Console.WriteLine("adder results: {0}", t5.Result);
Console.ReadKey();
}
public static int TaskWithResult(object o)
{
Tuple<int, int> adder = (Tuple<int, int>)o;
return adder.Item1 + adder.Item2;
}
同步调用
调用Task类的RunSynchronously()方法，可以实现同步调用，直接在当前线程上调用该任务。
public static void Main()
{
TaskMethod.DoTask("Just Main thread");
Task t1 = new Task(TaskMethod.DoTask, "using Run Sync");
t1.RunSynchronously();
//输出结果
//Just Main thread
//Task id: no task, Thread id: 9
//
//using Run Sync
//Task id:1, Thread id :9
}
指定连续任务
调用Task类的ContinueWith()方法，可以指定连续的任务。
public static void Main()
{
TaskFactory tf = new TaskFactory();
Task t1 = tf.StartNew(()=>
{
Console.WriteLine("Current Task id = {0}", Task.CurrentId);
Console.WriteLine("执行任务1\r\n");
Thread.Sleep(10);
});
Task t2 = t1.ContinueWith((t) =>
{
Console.WriteLine("Last Task id = {0}", t.Id);
Console.WriteLine("Current Task id = {0}", Task.CurrentId);
Console.WriteLine("执行任务2\r\n");
Thread.Sleep(10);
});
Task t3 = t2.ContinueWith(delegate(Task t)
{
Console.WriteLine("Last Task id = {0}", t.Id);
Console.WriteLine("Current Task id = {0}", Task.CurrentId);
Console.WriteLine("执行任务3\r\n");
}, TaskContinuationOptions.OnlyOnRanToCompletion);
Console.ReadKey();
}
//执行结果
//
//Current Task id = 1
//执行任务1
//Last Task id = 1
//Current Task id = 2
//执行任务2
//Last Task id = 2
//Current Task id = 3
//执行任务3
从执行结果可以看出，任务1，2，3被顺序执行，同时通过 TaskContinuationOptions 还可以指定何种情况下继续执行该任务，常用的值包括OnlyOnFaulted, OnlyOnCanceled, NotOnFaulted, NotOnCanceled等。如将上例中的OnlyOnRanToCompletion改为OnlyOnFaulted，任务2结束之后，任务3将不被执行。
对于ContinueWith()的使用，MSDN演示了更加优雅的“流式”调用方法：
private void Button1_Click(object sender, EventArgs e)
{
var backgroundScheduler = TaskScheduler.Default;
var uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();
Task.Factory.StartNew(delegate { DoBackgroundComputation(); },
backgroundScheduler).
ContinueWith(delegate { UpdateUI(); }, uiScheduler).
ContinueWith(delegate { DoAnotherBackgroundComputation(); },
backgroundScheduler).
ContinueWith(delegate { UpdateUIAgain(); }, uiScheduler);
}
任务的层次结构
如果在一个Task内部创建了另一个任务，这两者间就存在父/子的层次结构，当父任务被取消时，子任务也会被取消。如果不希望使用该层次结构，可在创建子任务时选择TaskCreationOptions.DetachedFromParent。
5. BackgroundWorker控件
除了上述四类直接操作多线程的方法，C#还提供了BackgroundWorker控件帮助用户更简单、安全地实现多线程运算。该控件提供了DoWork, ProgressChanged 和 RunWorkerCompleted事件，为DoWork添加事件处理函数，再调用RunWorkerAsync()方法，即可创建一个新的线程执行DoWork任务。ProgressChanged和RunWorkerCompleted事件均在UI线程中执行，添加相应的处理函数，即可完成任务线程与UI线程间的交互，可用于显示任务的执行状态（完成百分比）、执行结果等。同时，该控件还提供了CancleAsync()方法，以中断线程的执行，需注意的是，调用该方法后，只是将控件的CancellationPending属性置True，用户需在程序执行过程中查询该属性以判定是否应中断线程。
具体用法可参考MSDN：BackgroundWorker用法范例
