c#基础知识---多线程

线程 被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及到复杂的和耗时的操作，那么设置不同的线程执行路径往往是有益的，每个线程执行特定的工作。

线程是轻量级进程。一个使用线程的常见实例是现代操作系统中并行编程的实现。使用线程节省了 CPU 周期的浪费，同时提高了应用程序的效率。

到目前为止我们编写的程序是一个单线程作为应用程序的运行实例的单一的过程运行的。但是，这样子应用程序同时只能执行一个任务。为了同时执行多个任务，它可以被划分为更小的线程。

线程生命周期

线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。

下面列出了线程生命周期中的各种状态：

未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。 就绪状态：当线程准备好运行并等待 CPU 周期时的状况。 不可运行状态：下面的几种情况下线程是不可运行的：

已经调用 Sleep 方法 已经调用 Wait 方法 通过 I/O 操作阻塞 死亡状态：当线程已完成执行或已中止时的状况。

主线程

在 C# 中，System.Threading.Thread 类用于线程的工作。它允许创建并访问多线程应用程序中的单个线程。进程中第一个被执行的线程称为主线程。

当 C# 程序开始执行时，主线程自动创建。使用 Thread 类创建的线程被主线程的子线程调用。您可以使用 Thread 类的 CurrentThread 属性访问线程。

下面的程序演示了主线程的执行：

using System; using System.Threading; namespace MultithreadingApplication { class MainThreadProgram { static void Main(string[] args) { Thread th = Thread.CurrentThread; th.Name = "MainThread"; Console.WriteLine("This is {0}", th.Name); Console.ReadKey(); } } }

当上面的代码被编译和执行时，它会产生下列结果：

This is MainThread

创建线程

线程是通过扩展 Thread 类创建的。扩展的 Thread 类调用 Start() 方法来开始子线程的执行。

下面的程序演示了这个概念：

using System; using System.Threading; namespace MultithreadingApplication { class ThreadCreationProgram { public static void CallToChildThread() { Console.WriteLine("Child thread starts"); } static void Main(string[] args) { ThreadStart childref = new ThreadStart(CallToChildThread); Console.WriteLine("In Main: Creating the Child thread"); Thread childThread = new Thread(childref); childThread.Start(); Console.ReadKey(); } } }

当上面的代码被编译和执行时，它会产生下列结果：

In Main: Creating the Child thread Child thread starts

管理线程

Thread 类提供了各种管理线程的方法。

下面的实例演示了 sleep() 方法的使用，用于在一个特定的时间暂停线程。

using System; using System.Threading; namespace MultithreadingApplication { class ThreadCreationProgram { public static void CallToChildThread() { Console.WriteLine("Child thread starts"); // 线程暂停 5000 毫秒 int sleepfor = 5000; Console.WriteLine("Child Thread Paused for {0} seconds", sleepfor / 1000); Thread.Sleep(sleepfor); Console.WriteLine("Child thread resumes"); } static void Main(string[] args) { ThreadStart childref = new ThreadStart(CallToChildThread); Console.WriteLine("In Main: Creating the Child thread"); Thread childThread = new Thread(childref); childThread.Start(); Console.ReadKey(); } } }

当上面的代码被编译和执行时，它会产生下列结果：

In Main: Creating the Child thread Child thread starts Child Thread Paused for 5 seconds Child thread resumes

销毁线程

Abort() 方法用于销毁线程。

通过抛出 threadabortexception 在运行时中止线程。这个异常不能被捕获，如果有 finally 块，控制会被送至 finally 块。

下面的程序说明了这点：

using System; using System.Threading; namespace MultithreadingApplication { class ThreadCreationProgram { public static void CallToChildThread() { try { Console.WriteLine("Child thread starts"); // 计数到 10 for (int counter = 0; counter <= 10; counter++) { Thread.Sleep(500); Console.WriteLine(counter); } Console.WriteLine("Child Thread Completed"); } catch (ThreadAbortException e) { Console.WriteLine("Thread Abort Exception"); } finally { Console.WriteLine("Couldn't catch the Thread Exception"); } } static void Main(string[] args) { ThreadStart childref = new ThreadStart(CallToChildThread); Console.WriteLine("In Main: Creating the Child thread"); Thread childThread = new Thread(childref); childThread.Start(); // 停止主线程一段时间 Thread.Sleep(2000); // 现在中止子线程 Console.WriteLine("In Main: Aborting the Child thread"); childThread.Abort(); Console.ReadKey(); } } }

当上面的代码被编译和执行时，它会产生下列结果：

In Main: Creating the Child thread Child thread starts 0 1 2 In Main: Aborting the Child thread Thread Abort Exception Couldn't catch the Thread Exception

线程函数通过委托传递，可以不带参数，也可以带参数（只能有一个参数），可以用一个类或结构体封装参数:

using System; using System.Threading; namespace Test {     class Program     {         static void Main(string[] args)         {             Thread t1 = new Thread(new ThreadStart(TestMethod));             Thread t2 = new Thread(new ParameterizedThreadStart(TestMethod));             t1.IsBackground = true;             t2.IsBackground = true;             t1.Start();             t2.Start("hello");             Console.ReadKey();         }         public static void TestMethod()         {             Console.WriteLine("不带参数的线程函数");         }         public static void TestMethod(object data)         {             string datastr = data as string;             Console.WriteLine("带参数的线程函数，参数为：{0}", datastr);         }     } }

线程的销毁

（1）线程自动销毁

Thread a=new Thread(Method) th.start();

线程方法Method执行完结,线程a也自动终止.

（2）如果是无限循环需要手动销毁

窗体应用程序的线程间通信

.net 2.0以后加强了安全机制，不允许在winform中直接跨线程访问控件的属性。

线程函数通过委托传递，是一种安全的线程间通信的方式。也是委托的功能之一。

但C#也可以关闭线程安全保护，自由的调用其他线程生成的控件。只要加上

Control.CheckForIllegalCrossThreadCalls = false;

但不推荐使用。自己练习时可以写着玩一下。

本篇文章的第二段代码创建线程中，在2.0以后可以直接执行子线程，这样一来程序可以省略Main函数中的第一行代码。运行结果一样，似乎程序会更简单易懂点。如下：

using System.Threading.Tasks; using System.Threading; namespace ConsoleApp { class Program { public static void CallToChildThread() { Console.WriteLine("Child thread starts"); } static void Main(string[] args) { //ThreadStart childref = new ThreadStart(CallToChildThread); Console.WriteLine("In Main: Creating the Child thread"); Thread childThread = new Thread(CallToChildThread); childThread.Start(); Console.ReadKey(); } } }

C# 在 4.0 以后一共有3种创建线程的方式:

 1.Thread 自己创建的独立的线程, 优先级高,需要使用者自己管理。 2.ThreadPool 有 .Net 自己管理, 只需要把需要处理的方法写好, 然后交个.Net Framework, 后续只要方法执行完毕, 则自动退出。 3.Task 4.0 以后新增的线程操作方式, 类似 ThreadPool, 但效率测试比ThreadPool略高, Task对多核的支持更为明显,所以在多核的处理器中, Task的优势更为明显。 class Program { static void Main(string[] args) { //独立创建线程 Thread t = new Thread(ThreadProcess); t.Start(new object()); //线程池 ThreadPool.QueueUserWorkItem(ThreadProcess, new object()); //Task方式创建线程 System.Threading.Tasks.Task.Factory.StartNew(ThreadProcess, new object()); //需要手动终止,当然现在终止可能线程还未运行完成, t.Abort(); } private static void ThreadProcess(object tag) { int i = 100; while (i > 0) { Console.WriteLine(string.Format("i:{0} ", i)); Thread.Sleep(10); i--; } } }