C#综合揭秘——细说多线程

一、线程的基础知识

　　1. 1 System.Threading.Thread类

　　System.Threading.Thread是用于控制线程的基础类，通过Thread可以控制当前应用程序域中线程的创建、挂起、停止、销毁。

　　它包括以下常用公共属性：

属性名称	说明
CurrentContext	获取线程正在其中执行的当前上下文。
CurrentThread	获取当前正在运行的线程。
ExecutionContext	获取一个 ExecutionContext 对象，该对象包含有关当前线程的各种上下文的信息。
IsAlive	获取一个值，该值指示当前线程的执行状态。
IsBackground	获取或设置一个值，该值指示某个线程是否为后台线程。
IsThreadPoolThread	获取一个值，该值指示线程是否属于托管线程池。
ManagedThreadId	获取当前托管线程的唯一标识符。
Name	获取或设置线程的名称。
Priority	获取或设置一个值，该值指示线程的调度优先级。
ThreadState	获取一个值，该值包含当前线程的状态。

　　1. 1.1 线程的标识符

　　ManagedThreadId是确认线程的唯一标识符，程序在大部分情况下都是通过Thread.ManagedThreadId来辨别线程的。而Name是一个可变值，在默认时候，Name为一个空值 Null，开发人员可以通过程序设置线程的名称，但这只是一个辅助功能。　　

　　1. 1.2 线程的优先级别

　　.NET为线程设置了Priority属性来定义线程执行的优先级别，里面包含5个选项，其中Normal是默认值。除非系统有特殊要求，否则不应该随便设置线程的优先级别。　　

成员名称	说明
Lowest	可以将 Thread 安排在具有任何其他优先级的线程之后。
BelowNormal	可以将 Thread 安排在具有 Normal 优先级的线程之后，在具有 Lowest 优先级的线程之前。
Normal	默认选择。可以将 Thread 安排在具有 AboveNormal 优先级的线程之后，在具有 BelowNormal 优先级的线程之前。
AboveNormal	可以将 Thread 安排在具有 Highest 优先级的线程之后，在具有 Normal 优先级的线程之前。
Highest	可以将 Thread 安排在具有任何其他优先级的线程之前。

　　1. 1.3 线程的状态

　　通过ThreadState可以检测线程是处于Unstarted、Sleeping、Running 等等状态，它比 IsAlive 属性能提供更多的特定信息。

　　前面说过，一个应用程序域中可能包括多个上下文，而通过CurrentContext可以获取线程当前的上下文。

　　CurrentThread是最常用的一个属性，它是用于获取当前运行的线程。　　

　　1. 1.4 System.Threading.Thread的方法

　　Thread 中包括了多个方法来控制线程的创建、挂起、停止、销毁，以后来的例子中会经常使用。

方法名称	说明
Abort()	终止本线程。
GetDomain()	返回当前线程正在其中运行的当前域。
GetDomainId()	返回当前线程正在其中运行的当前域Id。
Interrrupt()	中断处于 WaitSleepJoin 线程状态的线程。
Join()	已重载。 阻塞调用线程，直到某个线程终止时为止。
Resume()	继续运行已挂起的线程。
Start()	执行本线程。
Suspend()	挂起当前线程，如果当前线程已属于挂起状态则此不起作用
Sleep()	把正在运行的线程挂起一段时间。

　　1. 1.5 开发实例

　　以下这个例子，就是通过Thread显示当前线程信息

static void Main(string[] args)
{
    Thread thread = Thread.CurrentThread;
    thread.Name = "Main Thread";
    string threadMessage = string.Format("Thread ID:{0}
    Current AppDomainId:{1}
    "+
        "Current ContextId:{2}
    Thread Name:{3}
    "+
        "Thread State:{4}
    Thread Priority:{5}
",
        thread.ManagedThreadId, Thread.GetDomainID(), Thread.CurrentContext.ContextID,
        thread.Name, thread.ThreadState, thread.Priority);
    Console.WriteLine(threadMessage);
    Console.ReadKey();
}

运行结果

　　1. 2  System.Threading 命名空间

　　在System.Threading命名空间内提供多个方法来构建多线程应用程序，其中ThreadPool与Thread是多线程开发中最常用到的，在.NET中专门设定了一个CLR线程池专门用于管理线程的运行，这个CLR线程池正是通过ThreadPool类来管理。而Thread是管理线程的最直接方式，下面几节将详细介绍有关内容。

类	说明
AutoResetEvent	通知正在等待的线程已发生事件。无法继承此类。
ExecutionContext	管理当前线程的执行上下文。无法继承此类。
Interlocked	为多个线程共享的变量提供原子操作。
Monitor	提供同步对对象的访问的机制。
Mutex	一个同步基元，也可用于进程间同步。
Thread	创建并控制线程，设置其优先级并获取其状态。
ThreadAbortException	在对 Abort 方法进行调用时引发的异常。无法继承此类。
ThreadPool	提供一个线程池，该线程池可用于发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。
Timeout	包含用于指定无限长的时间的常数。无法继承此类。
Timer	提供以指定的时间间隔执行方法的机制。无法继承此类。
WaitHandle	封装等待对共享资源的独占访问的操作系统特定的对象。

　　在System.Threading中的包含了下表中的多个常用委托，其中ThreadStart、ParameterizedThreadStart是最常用到的委托。

　　由ThreadStart生成的线程是最直接的方式，但由ThreadStart所生成并不受线程池管理。

　　而ParameterizedThreadStart是为异步触发带参数的方法而设的，在下一节将为大家逐一细说。

委托说明
ContextCallback	表示要在新上下文中调用的方法。
ParameterizedThreadStart	表示在 Thread 上执行的方法。
ThreadExceptionEventHandler	表示将要处理 Application 的 ThreadException 事件的方法。
ThreadStart	表示在 Thread 上执行的方法。
TimerCallback	表示处理来自 Timer 的调用的方法。
WaitCallback	表示线程池线程要执行的回调方法。
WaitOrTimerCallback	表示当 WaitHandle 超时或终止时要调用的方法。

二、以ThreadStart方式实现多线程

　　2. 1 使用ThreadStart委托

　　这里先以一个例子体现一下多线程带来的好处，首先在Message类中建立一个方法ShowMessage()，里面显示了当前运行线程的Id，并使用Thread.Sleep（int ) 方法模拟部分工作。在main()中通过ThreadStart委托绑定Message对象的ShowMessage（）方法，然后通过Thread.Start（）执行异步方法。

public class Message
{
    public void ShowMessage()
    {
        string message = string.Format("Async threadId is :{0}", Thread.CurrentThread.ManagedThreadId);
        Console.WriteLine(message);

        for (int n = 0; n < 10; n++)
        {
            Thread.Sleep(300);   
            Console.WriteLine("The number is:" + n.ToString()); 
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Main threadId is:"+ Thread.CurrentThread.ManagedThreadId);
        Message message=new Message();
        Thread thread = new Thread(new ThreadStart(message.ShowMessage));
        thread.Start();
        Console.WriteLine("Do something ..........!");
        Console.WriteLine("Main thread working is complete!");
        
    }
}

　　请注意运行结果，在调用Thread.Start()方法后，系统以异步方式运行Message.ShowMessage()，而主线程的操作是继续执行的，在Message.ShowMessage()完成前，主线程已完成所有的操作。

　　2. 2 使用ParameterizedThreadStart委托

　　ParameterizedThreadStart委托与ThreadStart委托非常相似，但ParameterizedThreadStart委托是面向带参数方法的。注意ParameterizedThreadStart 对应方法的参数为object，此参数可以为一个值对象，也可以为一个自定义对象。

public class Person
{
    public string Name
    {
        get;
        set;
    }
    public int Age
    {
        get;
        set;
    }
}

public class Message
{
    public void ShowMessage(object person)
    {
        if (person != null)
        {
            Person _person = (Person)person;
            string message = string.Format("
{0}'s age is {1}!
Async threadId is:{2}",
                _person.Name,_person.Age,Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
        }
        for (int n = 0; n < 10; n++)
        {
            Thread.Sleep(300);   
            Console.WriteLine("The number is:" + n.ToString()); 
        }
    }
}

class Program
{
    static void Main(string[] args)
    {     
        Console.WriteLine("Main threadId is:"+Thread.CurrentThread.ManagedThreadId);
        
        Message message=new Message();
        //绑定带参数的异步方法
        Thread thread = new Thread(new ParameterizedThreadStart(message.ShowMessage));
        Person person = new Person();
        person.Name = "Jack";
        person.Age = 21;
        thread.Start(person);  //启动异步线程 
        
        Console.WriteLine("Do something ..........!");
        Console.WriteLine("Main thread working is complete!");
         
    }
}

运行结果：

　　2. 3 前台线程与后台线程

　　注意以上两个例子都没有使用Console.ReadKey（），但系统依然会等待异步线程完成后才会结束。这是因为使用Thread.Start()启动的线程默认为前台线程，而系统必须等待所有前台线程运行结束后，应用程序域才会自动卸载。

　　在第二节曾经介绍过线程Thread有一个属性IsBackground，通过把此属性设置为true，就可以把线程设置为后台线程！这时应用程序域将在主线程完成时就被卸载，而不会等待异步线程的运行。

　　2. 4 挂起线程

　　为了等待其他后台线程完成后再结束主线程，就可以使用Thread.Sleep()方法。

public class Message
{
    public void ShowMessage()
    {
        string message = string.Format("
Async threadId is:{0}",
                                       Thread.CurrentThread.ManagedThreadId);
        Console.WriteLine(message);
        for (int n = 0; n < 10; n++)
        {
            Thread.Sleep(300);
            Console.WriteLine("The number is:" + n.ToString());
        }
    }
}

class Program
{
    static void Main(string[] args)
    {     
        Console.WriteLine("Main threadId is:"+
                          Thread.CurrentThread.ManagedThreadId);
        
        Message message=new Message();
        Thread thread = new Thread(new ThreadStart(message.ShowMessage));
        thread.IsBackground = true;
        thread.Start();
        
        Console.WriteLine("Do something ..........!");
        Console.WriteLine("Main thread working is complete!");
        Console.WriteLine("Main thread sleep!");
        Thread.Sleep(5000);
    }
}

　　运行结果如下，此时应用程序域将在主线程运行5秒后自动结束

　　但系统无法预知异步线程需要运行的时间，所以用通过Thread.Sleep（int）阻塞主线程并不是一个好的解决方法。有见及此，.NET专门为等待异步线程完成开发了另一个方法thread.Join()。把上面例子中的最后一行Thread.Sleep（5000）修改为 thread.Join() 就能保证主线程在异步线程thread运行结束后才会终止。

　　2. 5 终止线程

　　若想终止正在运行的线程，可以使用Abort（）方法。在使用Abort（）的时候，将引发一个特殊异常 ThreadAbortException 。

　　若想在线程终止前恢复线程的执行，可以在捕获异常后 ，在catch（ThreadAbortException ex）{...} 中调用Thread.ResetAbort（）取消终止。

　　而使用Thread.Join（）可以保证应用程序域等待异步线程结束后才终止运行。

static void Main(string[] args)
{
    Console.WriteLine("Main threadId is:" +
                      Thread.CurrentThread.ManagedThreadId);

    Thread thread = new Thread(new ThreadStart(AsyncThread));
    thread.IsBackground = true;
    thread.Start();
    thread.Join();

}     

//以异步方式调用
static void AsyncThread()
{
    try
    {
        string message = string.Format("
Async threadId is:{0}",
           Thread.CurrentThread.ManagedThreadId);
        Console.WriteLine(message);

        for (int n = 0; n < 10; n++)
        {
            //当n等于4时，终止线程
            if (n >= 4)
            {
                Thread.CurrentThread.Abort(n);
            }
            Thread.Sleep(300);
            Console.WriteLine("The number is:" + n.ToString());
        }
    }
    catch (ThreadAbortException ex)
    {
        //输出终止线程时n的值
        if (ex.ExceptionState != null)
            Console.WriteLine(string.Format("Thread abort when the number is: {0}!", 
                                             ex.ExceptionState.ToString()));
       
        //取消终止，继续执行线程
        Thread.ResetAbort();
        Console.WriteLine("Thread ResetAbort!");
    }

    //线程结束
    Console.WriteLine("Thread Close!");
}

　　运行结果如下