C#多线程学习手册.docx

C#多线程学习手册.docx

《C#多线程学习手册.docx》由会员分享，可在线阅读，更多相关《C#多线程学习手册.docx（70页珍藏版）》请在冰豆网上搜索。

C#多线程学习手册

C#中的线程

注：

文章系参考转载，英文原文网址请参考:

作者：

JosephAlbahari, 翻译：

 SwankyWu

要点：

∙入门

∙概述与概念

∙创建和开始使用多线程

∙线程同步基础

∙同步要领

∙锁和线程安全

∙Interrupt和Abort

∙线程状态

∙等待句柄

∙同步环境

∙使用多线程

∙单元模式和WindowsForms

∙BackgroundWorker类

∙ReaderWriterLock类

∙线程池

∙异步委托

∙计时器

∙局部储存

∙高级话题

∙非阻止同步

∙Wait和Pulse

∙Suspend和Resume

∙终止线程

一、入门

1. 概述与概念

 C#支持通过多线程并行地执行代码，一个线程有它独立的执行路径，能够与其它的线程同时地运行。

一个C#程序开始于一个单线程，这个单线程是被CLR和操作系统（也称为“主线程”）自动创建的，并具有多线程创建额外的线程。

这里的一个简单的例子及其输出：

     除非被指定，否则所有的例子都假定以下命名空间被引用了：

usingSystem;

usingSystem.Threading;

class ThreadTest

{

  static void Main（）

{

    Threadt=new Thread（WriteY）;

    t.Start（）;                         //RunWriteYonthenewthread

    while （true）

Console.Write（"x"）;  //Write'x'forever

  }

  static void WriteY（）

{

    while （true）

Console.Write（"y"）;  //Write'y'forever

  }

}

 主线程创建了一个新线程“t”，它运行了一个重复打印字母"y"的方法，同时主线程重复但因字母“x”。

CLR分配每个线程到它自己的内存堆栈上，来保证局部变量的分离运行。

在接下来的方法中我们定义了一个局部变量，然后在主线程和新创建的线程上同时地调用这个方法。

static void Main（）

{

  new Thread（Go）.Start（）;     //CallGo（）onanewthread

  Go（）;                        //CallGo（）onthemainthread

}

static void Go（）

{

  //Declareandusealocalvariable-'cycles'

  for （int cycles=0;cycles<5;cycles++）

Console.Write（'?

'）;

}

变量cycles的副本分别在各自的内存堆栈中创建，输出也一样，可预见，会有10个问号输出。

当线程们引用了一些公用的目标实例的时候，他们会共享数据。

下面是实例：

class ThreadTest

{

 bool done;

   static void Main（）

{

   ThreadTesttt=new ThreadTest（）;  //Createacommoninstance

   new Thread（tt.Go）.Start（）;

   tt.Go（）;

 }

 //NotethatGoisnowaninstancemethod

 void Go（）

{

   if （!

done）

{

done=true;

Console.WriteLine（"Done"）;

}

 }

}

 因为在相同的ThreadTest实例中，两个线程都调用了Go（），它们共享了done字段，这个结果输出的是一个"Done"，而不是两个。

 静态字段提供了另一种在线程间共享数据的方式，下面是一个以done为静态字段的例子：

class ThreadTest

{

 static bool done;   //Staticfieldsaresharedbetweenallthreads

 static void Main（）

{

   new Thread（Go）.Start（）;

   Go（）;

 }

 static void Go（）

{

   if （!

done）

{

done=true;

Console.WriteLine（"Done"）;

}

 }

}

 上述两个例子足以说明，另一个关键概念，那就是线程安全（或反之，它的不足之处!

）输出实际上是不确定的：

它可能（虽然不大可能），"Done"，可以被打印两次。

然而，如果我们在Go方法里调换指令的顺序，"Done"被打印两次的机会会大幅地上升：

static void Go（）

{

if （!

done）

{

Console.WriteLine（"Done"）;

done=true;

}

}

问题就是一个线程在判断if块的时候，正好另一个线程正在执行WriteLine语句——在它将done设置为true之前。

补救措施是当读写公共字段的时候，提供一个排他锁；C#提供了lock语句来达到这个目的：

class ThreadSafe

{

  static bool done;

  static object locker=new object（）;

  static void Main（）

{

    new Thread（Go）.Start（）;

    Go（）;

  }

  static void Go（）

{

    lock （locker）

{

      if （!

done）

{

Console.WriteLine（"Done"）;

done=true;

}

    }

  }

}

 当两个线程争夺一个锁的时候（在这个例子里是locker），一个线程等待，或者说被阻止到那个锁变的可用。

在这种情况下，就确保了在同一时刻只有一个线程能进入临界区，所以"Done"只被打印了1次。

代码以如此方式在不确定的多线程环境中被叫做线程安全。

临时暂停，或阻止是多线程的协同工作，同步活动的本质特征。

等待一个排它锁被释放是一个线程被阻止的原因，另一个原因是线程想要暂停或Sleep一段时间：

Thread.Sleep（TimeSpan.FromSeconds（30））;        //Blockfor30seconds

一个线程也可以使用它的Join方法来等待另一个线程结束：

Threadt=new Thread（Go）;          //AssumeGoissomestaticmethod

t.Start（）;

t.Join（）;                            //Wait（block）untilthreadtends

一个线程，一旦被阻止，它就不再消耗CPU的资源了。

 线程是如何工作的

线程被一个线程协调程序管理着——一个CLR委托给操作系统的函数。

线程协调程序确保将所有活动的线程被分配适当的执行时间；并且那些等待或阻止的线程——比如说在排它锁中、或在用户输入——都是不消耗CPU时间的。

在单核处理器的电脑中，线程协调程序完成一个时间片之后迅速地在活动的线程之间进行切换执行。

这就导致“波涛汹涌”的行为，例如在第一个例子，每次重复的X或Y块相当于分给线程的时间片。

在WindowsXP中时间片通常在10毫秒内选择要比CPU开销在处理线程切换的时候的消耗大的多。

（即通常在几微秒区间）

在多核的电脑中，多线程被实现成混合时间片和真实的并发——不同的线程在不同的CPU上运行。

这几乎可以肯定仍然会出现一些时间切片,由于操作系统的需要服务自己的线程，以及一些其他的应用程序。

线程由于外部因素（比如时间片）被中断被称为被抢占，在大多数情况下,一个线程方面在被抢占的那一时那一刻就失去了对它的控制权。

  线程vs.进程

  属于一个单一的应用程序的所有的线程逻辑上被包含在一个进程中，进程指一个应用程序所运行的操作系统单元。

线程于进程有某些相似的地方：

比如说进程通常以时间片方式与其它在电脑中运行的进程的方式与一个C#程序线程运行的方式大致相同。

二者的关键区别在于进程彼此是完全隔绝的。

线程与运行在相同程序其它线程共享（堆heap）内存，这就是线程为何如此有用：

一个线程可以在后台读取数据，而另一个线程可以在前台展现已读取的数据。

 何时使用多线程

多线程程序一般被用来在后台执行耗时的任务。

主线程保持运行，并且工作线程做它的后台工作。

对于WindowsForms程序来说，如果主线程试图执行冗长的操作，键盘和鼠标的操作会变的迟钝，程序也会失去响应。

由于这个原因，应该在工作线程中运行一个耗时任务时添加一个工作线程，即使在主线程上有一个有好的提示“处理中...”，以防止工作无法继续。

这就避免了程序出现由操作系统提示的“没有相应”，来诱使用户强制结束程序的进程而导致错误。

模式对话框还允许实现“取消”功能，允许继续接收事件，而实际的任务已被工作线程完成。

BackgroundWorker恰好可以辅助完成这一功能。

在没有用户界面的程序里，比如说WindowsService，多线程在当一个任务有潜在的耗时，因为它在等待另台电脑的响应（比如一个应用服务器，数据库服务器，或者一个客户端）的实现特别有意义。

用工作线程完成任务意味着主线程可以立即做其它的事情。

 另一个多线程的用途是在方法中完成一个复杂的计算工作。

这个方法会在多核的电脑上运行的更快，如果工作量被多个线程分开的话（使用Environment.ProcessorCount属性来侦测处理芯片的数量）。

  一个C#程序称为多线程的可以通过2种方式：

明确地创建和运行多线程，或者使用.NETframework的暗中使用了多线程的特性——比如BackgroundWorker类, 线程池，threadingtimer，远程服务器，或WebServices或ASP.NET程序。

在后面的情况，人们别无选择，必须使用多线程；一个单线程的ASP.NETwebserver不是太酷，即使有这样的事情；幸运的是，应用服务器中多线程是相当普遍的；唯一值得关心的是提供适当锁机制的静态变量问题。

 何时不要使用多线程

  多线程也同样会带来缺点，最大的问题是它使程序变的过于复杂，拥有多线程本身并不复杂，复杂是的线程的交互作用，这带来了无论是否交互是否是有意的，都会带来较长的开发周期，以及带来间歇性和非重复性的bugs。

因此，要么多线程的交互设计简单一些，要么就根本不使用多线程。

除非你有强烈的重写和调试欲望。

当用户频繁地分配和切换线程时，多线程会带来增加资源和CPU的开销。

在某些情况下，太多的I/O操作是非常棘手的，当只