大家好，欢迎来到IT知识分享网。

在Windows应用程序中，一个算术复杂的运算常常需要执行长时间运行的操作，这时操作的执行速度就显得非常重要，程序员可以使用线程对要执行的操作分段执行，这样就可以大大提高程序的运行速度和性能。

线程简介

每个正在操作系统上运行的应用程序都是一个进程，它可以包括一个线程或者多个线程，是操作系统分配处理器时间的基本单元。在进程中可以有多个线程同时执行代码，每个线程都维护异常处理程序调度优先级和一组系统用于在调度该线程前保存线程上下文的结构。

进程就好像是一个公司，公司中的每个员工相当于线程，公司想要运转正常，那就必须得有总负责人，这个总负责人就相当于主线程。

单线程

单线程顾名思义就是只有一个线程，默认情况下，系统为应用程序分配一个主线程，该线程执行程序中Main()方法，开始和结束的代码。

新建一个Windows应用程序，程序会在program.cs文件中自动生成一个main()方法，该方法就是主线程的启动入口点。main方法的代码如下：

namespace threading { static class Program { [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); } } }

在以上代码中，Application类的Run方法，主要用于设置当前项目的主窗体，这里设置的是form1窗体。

多线程

一般情况下，需要用户交互的软件，都必须尽可能快的对用户的活动做出反应，以便提供丰富多彩的用户体验，但同时他又必须执行必要的计算以便尽可能快的将数据展现给用户，这时就可以使用多线程来实现。

多线程可以提高对用户的响应速度，并且处理所需数据，以便几乎同时完成工作，使用多线程是一种最为强大的技术，在具有一个处理器的计算机上，多线程可以通过利用用户事件之间很小的时间间隔在后台处理数据来达到这种效果。例如通过使用多线程，在另一个线程正在重新计算同一应用程序中的数据表格的其它部分时，用户可以编辑该数据表格。

但是，使用多线程有好处的同时也有缺点，建议一般不要在程序中使用太多的线程，这样可以最大限度地减少操作系统资源的使用，并可提高性能。如果在程序中使用了多线程可能会产生一些问题：

1、系统将为进程、APPdomain对象和线程所需的上下文信息使用内存。因此，可以创建的进程、APPdomain对象和线程的数目会受到可用内存的限制。

2、跟踪大量的线程将占用大量的处理器时间，如果线程过多，则其中大多数线程都不会产生明显的进步，如果大多数当前线程处于一个进程中，则其它进程中线程的调度频率就会很低。

3、使用许多线程控制代码执行非常复杂，并且可能产生许多bug。

4、如果要销毁线程，就需要了解可能发生的问题，并对这些问题进行处理。

线程的基本操作

C#中对线程进行操作时主要用到了thread类，该类位于system.threading命名空间下，通过使用thread类可以对线程进行创建、暂停、恢复、休眠、终止及设置优先权等操作，另外还可以通过使用monitor类mutex类和lock关键字控制线程间的同步执行。

Thread类

它位于system.threading命名空间下，system.threading命名空间提供一些可以进行多线程编程的类和接口，除同步线程活动和访问数据的类(如Mutex、Monitor、AutoResetEvent等)外，该命名空间还包含一个ThreadPool类和一个Timer类，ThreadPool类允许用户使用系统提供的线程池，Timer类在线程池的线程上执行回调方法。

Thread类主要用于创建并控制线程，设置线程优先级并获取其状态，一个进程可以创建一个或多个线程以执行与该进程关联的部分程序代码，线程执行的程序代码由ThreadStart委托或ParameterizedThreadStart委托指定。

线程运行期间，不同的时刻会表现为不同的状态，但它总是处于由ThreadState定义的一个或多个状态中，用户可以通过使用ThreadPriority枚举为线程定义优先级，但不能保证操作系统会接受该优先级

thread类的常用属性及说明如表所示:

ApartmentState：//获取或设置该线程的单元状态 CurrentContext：//获取线程正在其中执行的当前上下文 CurrentThread：//获取当前正在运行的线程 IsAlive：//获取一个值，该值只是当前线程的执行状态。 ManagedThreadId：//获取当前托管线程的唯一标识符 Name：//获取或设置线程的名称 Priority：//获取或设置一个值该值指示线程的调度优先级 ThreadState：//获取一个值，该值包含当前线程的状态。

thread类的常用方法及说明:

Abort：//再调用该方法的线程上引发thread about exception已开始终止该线程的过程，调用该方法通常会终止线程 GetApartmentState：//返回一个ApartmentState值，该值指示单元状态 GetDomain：//返回当前线程正在其中运行的当前域 GetDomainID：//返回唯一的应用程序域标识符 Interrupt：//中断处于WaitSleeJoin线程状态的线程 Join：//阻止调用线程，直到某个线程终止时为止 ResetAbort：//取消为当前线程请求的Abort Resume：//继续已挂起的线程 SetApartmentState：//在线程启动前设置其单元状态 Sleep：//当将当前线程阻止指定的毫秒数 SpinWait：//导致线程等待由iterations参数定义的时间量 Start：//使线程被安排进行执行 Suspend：//挂起线程，或者如果线程已挂起，则不起作用， VolatileRead：//读取字段值，无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值 VolatileWrite：//立即向字段写入一个值，以使该值对计算机中的所有处理器都可见

thread类的使用

使用thread类的相关方法和属性，开始运行一个线程，并获得该线程的相关信息，程序开发步骤如下：

1、新建一个Windows应用程序，命名窗体为threads.cs

2、在threads窗体中添加一个RichTextBox控件，用来显示线程相关信息。

3、编写程序代码：在程序中使用线程时，需要在命名空间区域添加using System.Threading命名空间

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; using System.Threading; namespace threading { public partial class threads : Form { public threads() { InitializeComponent(); } private void threads_Load(object sender, EventArgs e) { string threadInfo = null; Thread thread = new Thread(new ThreadStart(threadOut)); thread.Start(); threadInfo = ":" + thread.ManagedThreadId; threadInfo += "\n :" + thread.Name; threadInfo += "\n :" + thread.ThreadState.ToString(); threadInfo += "\n :" + thread.Priority.ToString(); threadInfo += "\n :" + thread.IsBackground; Thread.Sleep(1000); thread.Abort(""); thread.Join(); MessageBox.Show("thread has finished"); rTBText.Text = threadInfo; } public void threadOut() { MessageBox.Show("the main thread start"); } } } 

4、运行程序

先后弹出如图所示的对话框，然后显示如图所示的主窗体，并在主窗体RichTextBox控件中显示获得的线程相关信息：

线程开始：

线程结束：

显示线程信息：

线程实例讲解

创建一个线程

只需进行声明，并为其提供线程起始点处的方法委托即可。创建新的线程时，需要使用thread类，这个类具有接受一个ThreadStart委托的构造函数。该委托包装了调用Start方法时，由新线程调用的方法。创建了thread类的对象之后，线程对象虽然已经存在和配置，但是并未创建实际的线程，只有在调用start方法后，才会创建实际的线程。

start方法用来使线程被执行，如果线程已经终止，就无法通过再次调用start方法来重新启动。它有两种重载形式：

1、导致操作系统将当前实例的状态更改ThreadState.Running

public void Start()

2、导致操作系统将当前实例的状态更改为ThreadState.Running，并选择提供包含线程执行的方法要使用的数据的对象

public void Start(Object parameter)//parameter指一个对象，包含线程执行的方法要使用的数据

3、创建一个控制台应用程序，自定义一个静态的void类型方法createThread，然后在Main方法中通过实例化Thread类对象创建一个新的线程，最后调用Start方法启动该线程，值得注意的是createThread线程的入口不带任何参数。

完整代码：

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { //声明线程 Thread threading; //用ThreadStart委托构建线程实例 threading = new Thread(new ThreadStart(buildThread)); //启动线程 threading.Start(); } public static void buildThread() { Console.WriteLine("建立线程"); } } } 

创建完一个线程并启动之后，还可以挂起、恢复、休眠或终止它，线程的挂起与恢复，分别可以通过调用Thread类中的Suspend的方法和Resume方法实现。

挂起和恢复线程

1、Suspend方法用来挂起线程，如果线程已经挂起则不起作用，语法如下：

Public Void Suspend()

调用Suspend方法挂起线程时，.NET允许要挂起的线程再执行几个指令，目的是为了到达.NET认为线程可以安全挂起的状态。

2、Resume方法用来继承已挂起的线程，语法如下：

Public Void Resume()

通过Resume方法来恢复被暂停的线程时，无论调用了多少次Suspend方法，调用Resume方法，均会使另一个线程脱离挂起状态，并导致该线程继续执行。

对上一个控制台应用程序改进，通过实例化Thread类对象构建一个新的线程，然后调用Start方法启动该线程之后，调用Suspend方法和Resume方法挂起和恢复创建的线程。

完整代码如下：

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { //声明线程 Thread threading; //用ThreadStart委托构建线程实例 threading = new Thread(new ThreadStart(buildThread)); //启动线程 threading.Start(); //挂起线程 threading.Suspend(); //恢复挂起的线程 threading.Resume(); } public static void buildThread() { Console.WriteLine("建立线程"); } } } 

线程休眠

主要通过thread类的sleep方法实现，该方法用来将当前线程阻止指定的时间，它有两种重载形式：

1、将当前线程挂起指定的时间，语法如下：

Public static void sleep(int millionsecondsTimeout）

millionsecondsTimeout：线程被阻止的毫秒数。

指定零以指示应挂起此线程，以使其他等待线程能够执行，指定Timeout.Infinite无限期阻止线程。

2、将当前线程阻止指定的时间，语法如下：

Public static void sleep (TimeSpan timeout)

timeout：线程被阻止的时间量的TimeSpan。指定零以指示应挂起此线程，以使其他等待线程能够执行，指定Timeout.Infinite以无限期阻止线程。

下面代码用来使当前线程休眠2秒钟：

Thread.sleep(2000)，使线程休眠2秒钟。

终止线程

可以分别使用thread类的abort方法和join方法实现：

1、abort方法用来终止线程，它有两种重载形式：

一是终止线程在调用该方法的线程上引发ThreadAbortException异常开始终止该线程的过程，语法如下：

Public Void Abort()

二是终止线程在调用该方法的线程上引发ThreadAbortException异常开始终止该线程，并同时提供有关线程终止的异常信息的过程

Public Void Abort(Object infoState)

infoState：一个对象，它包含应用程序特定的信息，如状态，该信息可供正被终止的线程使用。

创建一个控制台应用程序，在其中开始一个线程，然后调用thread类的Abort方法终止已开启的线程。

代码如下：

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { //声明线程 Thread threading; //用ThreadStart委托构建线程实例 threading = new Thread(new ThreadStart(buildThread)); //启动线程 threading.Start(); //终止线程 threading.Abort(); } public static void buildThread() { Console.WriteLine("建立线程"); } } } 

线程的Abort方法，用于永久地停止托管线程，调用Abort方法是公共语言运行库在目标线程中引发ThreadAbortException异常，目标线程可捕捉该异常，一旦线程被终止，它将无法重新启动。

2、join方法用来阻止调用线程，直到某个线程终止时为止，它有三种重载形式：

一是在继续执行标准的Com和SendMessage消息处理期间阻止调用线程，直到某个线程终止为止。语法如下:

Public Void Join()

二是在继续执行标准的Com和SendMessage消息处理期间阻止调用线程，直到某个线程终止或经过指定时间为止。

Public bool Join(int millionsecondsTimeout)

millionsecondsTimeout：等待线程终止的毫秒数。如果线程已终止则返回true，如果线程在经过参数指定的时间量后未终止，则返回false

三是在继续执行标准的Com和SendMessage消息处理期间阻止调用线程，直到某个线程终止或经过指定时间为止，语法如下：

Public static void sleep (TimeSpan timeout)

timeout：等待线程终止的时间量的TimeSpan。如果线程已终止则返回true，如果线程在经过参数指定的时间量后未终止，则返回false。

创建一个控制台应用程序，其中调用了thread类的join方法等待线程终止。

代码如下：

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { //声明线程 Thread threading; //用ThreadStart委托构建线程实例 threading = new Thread(new ThreadStart(buildThread)); //启动线程 threading.Start(); //阻止调用该线程，直到该线程终止 threading.Join(); } public static void buildThread() { Console.WriteLine("建立线程"); } } } 

如果在应用程序中使用了多线程，辅助线程还没有执行完毕，在关闭窗体时必须关闭辅助线程，否则会引发异常。

线程优先级

线程的优先级是指定一个线程相对于另一个线程的相对优先级，每个线程都有一个分配的优先级，在公共语言运行库内创建的线程，最初被分配为normal优先级，而在公共语言运行库外创建的线程，在进入公共语言运行库时，将保留其先前的优先级。

线程是根据其优先级来调度执行的，用于确定线程执行顺序的调度算法，随操作系统的不同而不同，在某些操作系统下，具有最高优先级的线程经过调度后总是首先运行。如果具有相同优先级的多个线程都可用，则程序将遍历处于该优先级的线程，并为每个线程提供一个固定的时间片段来执行。

只有具有较高优先级的线程才可以运行，具有较低优先级的线程不会执行，如果在给定的优先级上不再有可运行的线程，则程序将移到下一个较低的优先级，并在该优先级上调度线程来执行，如果具有较高优先级的线程可以运行，则具有较低优先级的线程将被抢先，并允许具有较高优先级的线程再次执行。

除此之外，当应用程序的用户界面在前台和后台之间移动时，操作系统还可以动态调整线程的优先级。一个线程的优先级不影响该线程的状态，在操作系统可以调度该线程之前必须为running。

线程的优先级值及说明：

AboveNormal：可以将thread安排在具有highest的优先级的线程之后，在具有normal优先级的线程之前， BelowNormal:可以将thread安排在具有normal优先级的线程之后，在具有Lowest优先级的线程之前。 Highest：可以将thread安排在具有任何其他优先级的线程之前。 Lowest：可以将thread安排在具有任何其他优先级的线程之后。 Normal：可以将thread安排在具有AboveNormal优先级的线程之后，在具有BelowNormal优先级的线程之前，默认情况下线程具有normal优先级。

开发人员可以通过访问线程的priority属性来获取和设置其优先级。priority属性用来获取或设置一个值，该值指示线程的调度优先级，语法如下：

Public ThreadPriority Priority { get; set; }

属性值ThreadPriority默认值为normal。

创建一个控制台应用程序，创建两个thread线程类对象，并设置第一个thread类对象的优先级为最低，然后调用start方法开启这两个线程。

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { //自定义声明线程 Thread thread1=new Thread(new ThreadStart(buildThread1)); //设置线程的调度优先级为最低 thread1.Priority = ThreadPriority.Lowest; //自定义声明线程 Thread thread2 = new Thread(new ThreadStart(buildThread2)); //开启线程一 thread1.Start(); //开启线程二 thread2.Start(); } public static void buildThread1() { Console.WriteLine("建立线程一"); } public static void buildThread2() { Console.WriteLine("建立线程二"); } } } 

运行程序后，由于设置thread1线程的调度优先级为最低，则优先执行thread2线程：

线程同步

在应用程序中使用多个线程的一个好处是每个线程都可以异步执行，对于Windows应用程序耗时的任务可以在后台执行，而使应用程序窗口和控件保持响应。

对于服务器应用程序，多线程处理提供了用不同线程处理每个传入请求的能力，否则，在完全满足前一个请求之前将无法处理每个新请求，然而线程的异步性意味着必须协调对资源的访问，否则两个或更多的线程可能在同一时间访问相同的资源，而每个线程都不知道其他线程的操作，结果将产生不可预知的数据损坏。

线程同步是指并发线程高效有序地访问共享资源所采用的技术，所谓同步是指某一时刻只有一个线程可以访问资源，只有当资源所有者主动放弃了代码或资源的所有权，使其他线程才可以使用这些资源，线程同步可以分别使用C#中的lock关键字、Monitor类和mutex类实现。

1、C#中的lock关键字

lock关键字可以用来确保代码块完整运行，而不会被其他线程中断，它是通过在代码块运行期间，为给定对象获取互斥锁来实现的。lock语句以关键字lock开头，它有一个作为参数的对象，在该参数的后面还有一个一次只能由一个线程执行的代码块，Lock语句的语法格式如下：

object myLock = new object(); lock(myLock) { //necessary code }

提供给lock语句的参数必须为基于引用类型的对象，该对象用来定义锁的范围，严格地说，提供给lock语句的参数只是用来唯一标识由多个线程共享的资源，所以它可以是任意类实例，然而该参数通常表示需要进行线程同步的资源。

如果一个容器对象被多个线程使用，则可以将该容器传递给lock语句，而lock语句中的代码块将访问该容器，如果其他线程在访问该容器前先锁定该容器，则对该对象的访问将是安全同步的。

但是，最好避免锁定public类型或不受应用程序控制的对象实例，如果该实例可以被公开访问，则可能会有问题，因为不受控制的代码也可能会锁定该对象，这将可能导致死锁及两个或更多个线程等待释放。

同一个对象出于同样的原因锁定公共数据类型，也可能导致问题，锁定字符串尤其危险，因为字符串被公共语言运行库暂留，整个程序中任何给定字符串都只有一个实例。因此，如果在应用程序进程中的任何具有相同内容的字符串上放置锁，那么将锁定应用程序中该字符串的所有实例 。

因此，最好锁定不会被占留的私有或受保护成员，事实上lock语句是用Monitor类来实现的，它等效于try、finally语句块。使用Lock关键字通常比直接使用Monitor类更好，一方面是因为lock更简洁，另一方面，是因为lock确保了即使受保护的代码引发异常，也可以释放基础监视器，这是通过finally关键字来实现的，无论是否引发异常，他都执行关联的代码块。

创建一个控制台应用程序，其中自定义一个myLockThread方法，该方法中使用lock关键字锁定当前线程，然后在main方法中通过program的类对象调用myLockThread自定义方法，代码如下：

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Program myLockProgram = new Program();//实例化类对象 myLockProgram.myLockThread();//调用方法（功能是锁定线程） } void myLockThread() { lock(this)//锁定当前线程来实现同步 { Console.WriteLine("为实现线程同步，对线程进行锁定处理"); } } } } 

2、使用monitor类实现线程同步

monitor类提供了同步对象的访问机制，它通过向单个线程授予对象锁，进而来控制访问对象，对象锁提供限制访问代码块的能力。当一个线程拥有对象锁时，其他任何线程都不能获取对象锁。

monitor类的主要功能如下：

一是它根据需要与某个对象相关联，二是它是未绑定的，可以直接从任何上下文对它进行调用，三是不能创建某monitor类的实例，需要注意的是，使用monitor类，锁定的是对象，而不是值类型。monitor类的常用方法及说明：

Enter：在指定对象上获取排他锁。

Exit：释放指定对象上的排他锁

Pulse：通知等待队列中的线程锁定对象状态的更改

PulseAll：通知所有的等待线程对象状态的更改

TryEnter：试图获取指定对象的排他锁

Wait：释放对象上的锁，并阻止当前的线程，直到它重新获取该锁

创建一个控制台应用程序，其中自定义一个myLockThread方法，该方法中使用monitor类的Enter方法锁定当前线程，然后再调用monitor类的Exit方法释放当前线程，最后在main方法中通过program的类对象调用myLockThread自定义方法，代码如下：

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Program myLockProgram = new Program();//实例化类对象 myLockProgram.myLockThread();//调用方法（功能是锁定线程） } void myLockThread() { Monitor.Enter(this);//锁定当前线程 Console.WriteLine("为实现线程同步，对线程进行锁定处理"); Monitor.Exit(this);//释放当前线程 } } } 

前面两个例子实现的功能是相同的，但是使用lock关键字更简单一些，那为何还要使用Monitor类呢？因为使用Monitor类有更好的控制能力，它可以使用Wait方法指示活动的线程等待一段时间，当线程完成操作时，还可以使用Pulse方法和PulseAll方法通知等待中的线程。

3、使用mutex类实现线程同步

当两个或更多线程需要同时访问一个共享资源时，系统需要使用同步机制来确定一次只有一个线程使用该资源，Mutex类是同步基元，它指向一个线程授予对共享资源的独占访问权，如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体，Mutex类与监视器类似，它防止多个线程在某一段时间，同时执行某个代码块，然而与监视器不同的是，Mutex类可以用来使跨进程的线程同步。

可以使用WaitHandle.WaitOne方法请求互斥体的所属权，拥有互斥体的线程可以在对WaitOne方法的重复调用中请求相同的互斥体，而不会阻止其执行，但线程必须调用同样多次的ReleaseMutex的方法以释放互斥体的所属权，Mutex类强制线程标识，因此互斥体只能由获得它的线程释放。

Mutex类的常用方法及说明：

Close：在派生类中被重写时，释放由当前WaitHandle持有的所有资源

OpenExisting：打开现有的已命名互斥体

ReleaseMutex：释放Mutex一次

SingleAndWait：向一个WaitHandle发出信号并等待另一个

WaitAll：等待指定数组中的所有元素都收到信号

WaitAny：等待指定数组中的任意元素收到信号

WaitOne：当在派生类中重写时，阻止当前线程，直到当前的WaitHandle收到信号儿。

使用mutex类实现线程同步很简单，首先实例化一个mutex类对象，它的构造函数中比较常用的有public mutex(bool initiallyOwned)，参数initiallyOwned指定了创建该对象的线程是否希望立即获得其所有权，当在一个资源得到保护的类中创建mutex类对象时，常将该参数设置为false，然后在需要单线程访问的地方，调用其等待方法，等待方法请求没有mutex对象的所有权。这时，如果该所有权被另一个线程所拥有，则阻塞请求线程，并将其放入等待队列中，请求线程将保持阻塞，直到mutex对象收到了其所有者线程发出将其释放的信号为止，所有者线程在终止时释放mutex对象或者调用ReleaseMutex方法来释放mutex对象。

尽管mutex类可以用于进程内的线程同步，但是使用Monitor类通常更为可取，因为Monitor监视器是专门为.net framework设计的，它可以更好地利用资源，相比之下mutex类是win32构造的包装，尽管mutex类比监视器更为强大，但是相对于monitor类，它所需要的互操作转换更消耗计算机资源。

创建一个控制台应用程序，其中自定义一个myLockThread方法，该方法中使用mutex类的WaitOne方法阻止当前线程，然后再调用mutex类的ReleaseMutex方法释放mutex对象，最后在main方法中通过program的类对象调用myLockThread自定义方法，代码如下：

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { Program myLockProgram = new Program();//实例化类对象 myLockProgram.myLockThread();//调用方法（功能是锁定线程） } void myLockThread() { Mutex myTestMutex = new Mutex(false);//实例化Mutex类对象 myTestMutex.WaitOne();//阻止当前线程 Console.WriteLine("为实现线程同步，对线程进行锁定处理"); myTestMutex.ReleaseMutex();//释放Mutex类对象 } } } 

以上是对线程的概念和分类进行了详细的介绍，thread类是C#中进行线程编程的主要类，大家应该熟练掌握对线程编程的基础知识和各种基本操作，才能在以后的实际开发中应用线程处理各种多任务问题，这样就能够做出友好优质的系统和软件。

结语：喜欢的请关注、转发、收藏！方便随时查看