线程的详解

来源：互联网发布：java sock5 编辑：程序博客网时间：2024/05/29 08:34

今天我们来看看线程的文章，相信大家对线程并不陌生，当提到线程时条件反射的会先想到一条线执行的程序，这样解释是否正确呢？我们姑且不讨论这个问题，要想知道这个答案去教材书上查看吧。这里需要思考一个问题，对于程序员来说线程并不陌生，但是你能区分进程和线程吗？

一、程序、进程、线程

1、线程--程序执行流的最小单元

线程是进程中的一个实体，是被系统独立调度和分派的基本单位。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

在单个程序中同时运行多个线程完成不同的工作，称为多线程。

线程运行三态图

2、进程--操作系统结构基础

进程可以看做一次程序的执行；是一个程序及其数据在处理机上顺序执行时所发生的活动；是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。

在计算机科学中，“线程”和“进程”是两个相关的概念。二者都表示必须按特定顺序执行的指令序列。但是不同线程或进程中的指令可以并行执行。进程存在于操作系统内，并对应于用户可看作为程序或应用程序的事物。另外，线程存在于进程内。因此，线程有时也称作“轻量进程”。每个进程都由一个或多个线程组成。

多个进程的存在使得计算机能够一次执行多个任务。而多个线程的存在使得进程能够分解工作以便并行执行。在多处理器计算机上，进程或线程可以在不同的处理器中运行。这使得真正的并行处理成为可能。

简单的说一个程序至少有一个进程，一个进程至少有一个线程。

二、.NET线程

.NET 提供了许多有助于创建和管理多线程应用程序的对象。其中最主要的是Thread类、ThreadPool类、和BackgroundWorker类，其中托管线程由 Thread 类表示， ThreadPool 类提供了创建和管理多线程后台任务的简便方法， BackgroundWorker 类为与用户界面交互的任务提供相同的功能， Timer 类按固定的时间间隔执行后台任务。

在创建操作系统进程时，操作系统将插入一个线程以执行该进程（包括任何原始应用程序域）中的代码。从此刻起，就可以创建和销毁应用程序域，而不必创建或销毁任何操作系统线程。如果正在执行的代码是托管代码，则可以通过检索类型为 Thread 的静态 CurrentThread 属性来获取正在当前应用程序域中执行的线程的 Thread 对象。

1、创建线程

创建新的 Thread 对象时，将创建新的托管线程。 Thread 类具有接受一个 ThreadStart 委托或 ParameterizedThreadStart 委托的构造函数：该委托包装调用 Start 方法时由新线程调用的方法。多次调用 Start 将引发 ThreadStateException。
Start 方法立即返回，经常是在实际启动新线程之前。可以使用 ThreadState 和 IsAlive 属性确定任何时刻的线程状态，但是绝不应该将这些属性用于同步线程活动。

Note:线程一旦启动，就不必保留对 Thread 对象的引用。该线程会继续执行，直到线程过程结束为止。

下面的代码示例创建两个新线程以调用另一个对象上的实例和静态方法。

[csharp] view plain copy

using System;
using System.Threading;
///<summary>
///线程执行类，封装了线程开始时执行的方法
///</summary>
public class ServerClass
{
///<summary>
///线程开始时执行此方法
///</summary>
public void InstanceMethod()
{
Console.WriteLine("ServerClass.InstanceMethod is running on another thread.");
// 线程延迟3000秒，使线程的执行更加明显
Thread.Sleep(3000);
Console.WriteLine("The instance method called by the worker thread has ended.");
}
///<summary>
///线程开始时执行此方法
///</summary>
public static void StaticMethod()
{
Console.WriteLine("ServerClass.StaticMethod is running on another thread.");
//线程延迟5000秒
Thread.Sleep(5000);
Console.WriteLine("The static method called by the worker thread has ended.");
}
}
///<summary>
///线程创建类，封装了线程创建及执行方法
///</summary>
public class Simple
{
public static void Main()
{
Console.WriteLine("Thread Simple Sample");
ServerClass serverObject = new ServerClass();
//创建线程对象，并传入serverObject.InstanceMethod方法
Thread InstanceCaller = new Thread(new ThreadStart(serverObject.InstanceMethod));
//开始执行线程
InstanceCaller.Start();
Console.WriteLine("The Main() thread calls this after "+ "starting the new InstanceCaller thread.");
//创建线程对象，并传入serverObject.InstanceMethod方法
Thread StaticCaller = new Thread(new ThreadStart(ServerClass.StaticMethod));
//开始线程
StaticCaller.Start();
Console.WriteLine("The Main() thread calls this after "+ "starting the new StaticCaller thread.");
}
}

上面的示例演示了线程的创建过程，在创建过程时为线程对象指定运行时的委托方法，最后使用Start方法来执行线程，另外还有一个重要的方法Sleep它能够控制线程的延迟时间，为线程指定执行时停顿的时间。

线程

多线程优缺点

多线程的使用会帮助程序提高响应速度，因为可以同时执行多个任务这样对比一个个的来完成任务来说提高了响应的速度，较之添加多CPU来说多线程提高了强大的技术来执行多个任务。虽然多线程提高了响应速度，但同时牺牲了资源，由于多线程的执行它会占用多个资源，为了避免资源访问的冲突，往往会在每个线程中都会创建自己的资源，这样导致了资源的浪费。另外如果线程过多，则其中大多数线程都不会产生明显的进度，如果大多数当前线程处于一个进程中，则其他进程中的线程的调度频率就会很低。

线程基本方法

下表包括了在线程编程过程中常用的基本方法。

可用于控制单个线程的方法

方法操作Start 使线程开始运行。Sleep使线程暂停指定的一段时间。Suspend在线程到达安全点时，使其暂停。Abort 在线程到达安全点时，使其停止。Resume重新启动挂起的线程Join使当前线程一直等到另一线程完成。在与超时值一起使用时，如果该线程在分配的时间内完成，此方法将返回 True。

Note：安全点是指代码中公共语言运行时可以安全地执行自动“垃圾回收”的位置。垃圾回收是指释放不再使用的变量并回收内存的过程。调用线程的 Abort 或 Suspend 方法时，公共语言运行时将对代码进行分析，确定让线程停止运行的适当位置。

Demo1：线程，方法--委托

自己做的一个小Demo来实现多线程，当点击开始按钮后会在文本框中填写数字，与此同时加载进度条，读取进度，点击暂停后线程会停止。另外可以在文本框中输入暂停时间来指定线程暂停时间，在暂停后继续执行。

Demo下载地址：线程常用方法示例

在点击开始按钮后会同时创建两个线程，分别为showNumThread和pBarThread，用来向文本框中写入数字和加载进度条。这里需要说明的是，一般情况下线程内部是不允许调用线程外创建的对象的，创建的两个线程都调用了线程外部的对象，是怎么实现的呢？使用的是委托来异步执行程序来实现了调用线程外部的方法。

[csharp] view plain copy

/// <summary>
/// 开始按钮事件，创建线程并为线程指定方法
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnStart_Click(object sender, EventArgs e)
{
pBarThread = new Thread(new ThreadStart(this.ExepBarShow)); //创建进度条线程
showNumThread = new Thread(new ThreadStart(this.ExeShowNum)); //创建显示文本框中的文字线程
//开始两个已创建的线程
this.StartThread(showNumThread);
this.StartThread(pBarThread);
}
/// <summary>
/// 使用委托执行ShowNumToText方法
/// </summary>
private void ExeShowNum()
{
try
{
MethodInvoker mInvoker = new MethodInvoker(this.ShowNumToText); //声明托管委托，并为委托执行执行的方法
//执行委托方法，向Text中写入文字
while (true)
{
this.BeginInvoke((Delegate)mInvoker); //异步执行执行的委托
Thread.Sleep(1000); //线程停顿1秒后继续执行
}
}
catch { }
}
/// <summary>
/// 先文本框txtNum中写入文字
/// </summary>
private void ShowNumToText()
{
i = i + 1; //i累加
txtNum.Text = txtNum.Text + " " + (i + 1).ToString(); //向txtNum中写入文字
}
/// <summary>
/// 执行pBarShow方法，加载进度条，让进度条读取进度
/// </summary>
private void ExepBarShow()
{
try
{
MethodInvoker mInvoker = new MethodInvoker(this.pBarShow); //声明并创建委托，为委托执行进度
//异步执行委托
while (true)
{
this.BeginInvoke((Delegate)mInvoker);
Thread.Sleep(10);
}
}
catch { }
}
/// <summary>
/// 执行进度条读取进度
/// </summary>
private void pBarShow()
{
this.pgBar.PerformStep();
}
/// <summary>
/// 线程开始方法
/// </summary>
/// <param name="th">Thread对象，需要开始的线程</param>
private void StartThread(Thread th) {
th.Start();
}
/// <summary>
/// 线程结束方法
/// </summary>
/// <param name="th">Thread对象，需要结束的线程</param>
private void EndThread(Thread th) {
th.Interrupt(); //中断线程
th.Abort(); //终止线程
th = null;
}
/// <summary>
/// 停止线程事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnStop_Click(object sender, EventArgs e)
{
try
{
this.TestThead(); //验证线程是否存在，如果没有存在将会抛错
this.EndThread(this.pBarThread); //结束线程
this.EndThread(this.showNumThread); //结束线程
}
catch (Exception ex)
{
//提示错误信息
MessageBox.Show(ex.Message , "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
/// <summary>
/// 终止线程事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnEnd_Click(object sender, EventArgs e)
{
try
{
this.TestThead(); //验证线程是否创建
this.EndThread(this.pBarThread);//结束线程
this.EndThread(this.showNumThread); //结束线程
txtNum.Text = ""; //清空文本框内容
i = 0; //数字充值
this.pgBar.Value = 0;//进度条重置
}
catch (Exception ex)
{
//显示错误信息
MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
/// <summary>
/// 执行指定线程停顿时间
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnStopMinute_Click(object sender, EventArgs e)
{
try
{
int j = int.Parse(textBox1.Text); //获取终止的时间
Thread.Sleep(j); //将线程暂停指定的时间
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
/// <summary>
/// 验证线程是否存在方法
/// </summary>
private void TestThead() {
if (pBarThread ==null)
{
throw new Exception ("未创建线程，请创建线程后操作！");
}
if (showNumThread == null)
{
throw new Exception ("未创建线程，请创建线程后操作！");
}
}

Demo2：Join方法使用实例

Join方法能在指定的线程中插入一个线程，当插入的线程执行完成后才会继续执行被插入的线程。.NET为我们重载了此方法，能够为方法传递参数来指定经过的时间，此时该方法的作用与Sleep相类似，执行经过多长时间后来执行被插入的线程。Join方法的灵活运行能够实现线程之间的执行顺序。

[csharp] view plain copy

using System;
using System.Threading;
namespace TestJoin
{
/// <summary>
/// Join方法验证实例，线程t1使用了join方法，线程t2没有使用join方法
/// </summary>
class Program
{
static void Main(string[] args)
{
//创建新线程，为线程执行行为
Thread t1 = new Thread(() =>
{
Thread.Sleep(1000);
Console.WriteLine("t1 is ending.");
});
t1.Start(); //开始线程
t1.Join(); //在主线程中插入t1线程，先执行t1，线程后执行主线程
Console.WriteLine("t1.Join() returned."); //执行主线程，提示t1已经完成
//创建新线程，为线程执行行为
Thread t2 = new Thread(() =>
{
Thread.Sleep(1000);
Console.WriteLine("t2 is ending.");
});
t2.Start(); //开始线程
Console.WriteLine("t2.Join() returned."); //执行主线程，提示t1已经完成
Console.ReadLine();
}
}
}
/*输出结果：
*t1 is ending.
*t1.Join() returned.
*
*t2.Join() returned.
*t2 is ending.
*/

输出结果：

从输出结果上分析可以得出，Join方法将创建的线程插入到了主线程中当执行完后再继续执行主线程，对应到Demo2中是线程t1插入到了主线程中，这样会首先执行t1线程在控制台上打印“t1 is ending”打印完成后t1线程结束，然后继续执行主线程来打印其它的文字。所以我们完全可以说Join方法是将一个线程插入到主线程中，当执行完插入的线程后再继续执行被插入的线程。

1、进程的同步和异步

1.1 进程同步

就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是必须一件一件事做，等前一件做完了才能做下一件事。就像早上起床后，先洗涮,然后才能吃饭，不能在洗涮没有完成时，就开始吃饭。按照这个定义，其实绝大多数函数都是同步调用。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。

最常见的例子就是MessageBox。该函数发送一个消息给某个窗口，在对方处理完消息之前，这个函数不返回。当对方处理完毕以后，该函数才把消息处理函数所返回的result值返回给调用者。

1.2 异步

       异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。
       以多线程为例，在运行一个程序时会把CPU分成多个线程来运行程序，这些互不影响的线程在同一时间运行实现了异步执行。

2、线程执行方法

2.1 调用线程时传递参数

细心的童鞋应该能够发现前篇博客在创建线程时传递给线程的参数使用的是ThreadStart委托，而且给线程执行的方法并没有参数，这样在调用时就不用关心传递参数的问题。其实.NET为我们提供了两种线程委托，一个是ThreadStart委托，在执行时不需要使用参数，另外一个是ParameterizedThreadStart委托，从它的字面意思上可以读出它是参数化的委托，也就是说使用该种委托将会能够为线程函数传递参数。也就是说 ParameterizedThreadStart 委托提供了一种简便方法，可以在调用 Thread.Start 方法重载时将包含数据的对象传递给线程。代码如下：

[csharp] view plain copy

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 委托执行线程过程，如下的代码示例：

[csharp] view plain copy

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();
}
}

运行结果：

2.2 执行线程后获取返回值

2.2.1 IAsyncResult+EndInvoke

在.NET中使用线程的方法很多，使用委托的BeginInvoke和EndInvoke方法就是其中之一。BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用，下面我们介绍两种方法从EndInvoke中获取返回值。

[csharp] view plain copy

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);
}
}

在运行上面的程序后，由于newTask方法通过Sleep延迟了2秒，因此，程序直到2秒后才输出最终结果（一个随机整数）。如果不调用EndInvoke方法，程序会立即退出，这是由于使用BeginInvoke创建的线程都是后台线程，这种线程一但所有的前台线程都退出后（其中主线程就是一个前台线程），不管后台线程是否执行完毕，都会结束线程，并退出程序。关于前台和后台线程的详细内容，将在后面的部分讲解。

2.2.2 使用回调方式返回结果

       上面介绍的方法虽然可以成功返回结果，也可以给用户一些提示，但在这个过程中，整个程序就象死了一样，要想在调用的过程中，程序仍然可以正常做其它的工作，就必须使用异步调用的方式。下面我们使用GUI程序来编写一个例子。
       下面的代码通过异步的方式访问的form上的一个textbox，因此，需要按ctrl+f5运行程序。并在form上放一些其他的可视控件，然在点击button1后，其它的控件仍然可以使用，就象什么事都没有发生过一样，在10秒后，在textbox1中将输出100。
       Note：不能直接按F5运行程序，否则无法在其他线程中访问这个textbox，关于如果在其他线程中访问GUI组件，前篇博客中已经提到。

[csharp] view plain copy

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); //异步执行方法
}
}

对于BeginInvoke方法，它有多种重载方式，这里用的是它的两个参数重载。第一个参数是回调方法委托类型，这个委托只有一个参数，就是IAsyncResult，如MethodCompleted方法所示。当method方法执行完后，系统会自动调用MethodCompleted方法。BeginInvoke的第二个参数需要向MethodCompleted方法中传递一些值，一般可以传递被调用方法的委托，如上面代码中的my。这个值可以使用IAsyncResult.AsyncState属性获得。

结语

上面提到执行部件和调用者通过三种途径返回结果：状态、通知和回调。可以使用哪一种依赖于执行部件的实现，除非执行部件提供多种选择，否则不受调用者控制。如果执行部件用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一种很严重的错误）。如果是使用通知的方式，效率则很高，因为执行部件几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。

看似简单的小问题实则有很多注意项，为了能达到优化和安全的目的，小问题也不简单。

0 0