C#多线程系列教程_百度文库
您的浏览器Javascript被禁用，需开启后体验完整功能，
享专业文档下载特权
&赠共享文档下载特权
&10W篇文档免费专享
&每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
C#多线程系列教程
&&【线程】是程序中的一个执行流,每个线程都有自己的专有寄存器(栈指针、程序计数器 等),但代码区是共享的,即不同的线程可以执行同样的函数。【多线程】是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程 来执行不同的任务,也就是说允许单个程序创建多个并行执行的线程来完成各自的 任务。
阅读已结束，下载本文需要
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
加入VIP
还剩37页未读，
定制HR最喜欢的简历
你可能喜欢浅谈C#多线程简单例子讲解
转载 &更新时间：日 14:20:10 & 作者：C#教程
本篇文章主要介绍了C#多线程简单例子，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
.NET将关于多线程的功能定义在System.Threading名字空间中。因此，要使用多线程，必须先声明引用此名字空间（using System.T）。
a.启动线程
顾名思义，“启动线程”就是新建并启动一个线程的意思，如下代码可实现：
Thread thread1 = new Thread(new ThreadStart( Count));
其中的 Count 是将要被新线程执行的函数。
b.杀死线程
“杀死线程”就是将一线程斩草除根，为了不白费力气，在杀死一个线程前最好先判断它是否还活着（通过 IsAlive 属性），然后就可以调用 Abort 方法来杀死此线程。
c.暂停线程
它的意思就是让一个正在运行的线程休眠一段时间。如 thread.Sleep(1000); 就是让线程休眠1秒钟。
这个用不着解释了。Thread类中hreadPRiority属性，它用来设置优先级，但不能保证操作系统会接受该优先级。一个线程的优先级可分为5种：Normal, AboveNormal, BelowNormal, Highest, Lowest。具体实现例子如下:
thread.Priority = ThreadPriority.H
e.挂起线程
Thread类的Suspend方法用来挂起线程，直到调用Resume，此线程才可以继续执行。如果线程已经挂起，那就不会起作用。
if (thread.ThreadState = ThreadState.Running)
thread.Suspend();
f.恢复线程
用来恢复已经挂起的线程，以让它继续执行，如果线程没挂起，也不会起作用。
if (thread.ThreadState = ThreadState.Suspended)
thread.Resume();
下面将列出一个例子，以说明简单的线程处理功能。此例子来自于帮助文档。
using System.T
// Simple threading scenario: Start a static method running
// on a second thread.
public class ThreadExample {
// The ThreadProc method is called when the thread starts.
// It loops ten times, writing to the console and yielding
// the rest of its time slice each time, and then ends.
public static void ThreadProc() {
for (int i = 0; i & 10; i++) {
Console.WriteLine("ThreadProc: {0}", i);
// Yield the rest of the time slice.
Thread.Sleep(0);
public static void Main() {
Console.WriteLine("Main thread: Start a second thread.");
// The constructor for the Thread class requires a ThreadStart
// delegate that represents the method to be executed on the
// thread. C# simplifies the creation of this delegate.
Thread t = new Thread(new ThreadStart(ThreadProc));
// Start ThreadProc. On a uniprocessor, the thread does not get
// any processor time until the main thread yields. Uncomment
// the Thread.Sleep that follows t.Start() to see the difference.
t.Start();
//Thread.Sleep(0);
for (int i = 0; i & 4; i++) {
Console.WriteLine("Main thread: Do some work.");
Thread.Sleep(0);
Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.");
Console.WriteLine("Main thread: ThreadProc.Join has returned. Press Enter to end program.");
Console.ReadLine();
此代码产生的输出类似如下内容：
Main thread: Start a second thread.
Main thread: Do some work.
ThreadProc: 0
Main thread: Do some work.
ThreadProc: 1
Main thread: Do some work.
ThreadProc: 2
Main thread: Do some work.
ThreadProc: 3
Main thread: Call Join(), to wait until ThreadProc ends.
ThreadProc: 4
ThreadProc: 5
ThreadProc: 6
ThreadProc: 7
ThreadProc: 8
ThreadProc: 9
Main thread: ThreadProc.Join has returned. Press Enter to end program.
在Visul C#中System.Threading 命名空间提供一些使得可以进行多线程编程的类和接口，其中线程的创建有以下三种方法：Thread、ThreadPool、Timer。下面就它们的使用方法逐个作一简单介绍。
一、Thread
这也许是最复杂的方法，但它提供了对线程的各种灵活控制。首先你必须使用它的构造函数创建一个线程实例，它的参数比较简单，只有一个ThreadStart 委托：public Thread(ThreadStart start);然后调用Start()启动它，当然你可以利用它的Priority属性来设置或获得它的运行优先级(enum ThreadPriority： Normal、 Lowest、 Highest、 BelowNormal、 AboveNormal)。
下例首先生成了两个线程实例t1和t2，然后分别设置它们的优先级，接着启动两线程(两线程基本一样，只不过它们输出不一样，t1为“1”，t2为“2”，根据它们各自输出字符个数比可大致看出它们占用CPU时间之比,这也反映出了它们各自的优先级)。
static void Main(string[] args)
Thread t1 = new Thread(new ThreadStart(Thread1));
Thread t2 = new Thread(new ThreadStart(Thread2));
t1.Priority = ThreadPriority.BelowN
t2.Priority = ThreadPriority.L
t1.Start();
t2.Start();
public static void Thread1()
for (int i = 1; i & 1000; i++)
{//每运行一个循环就写一个“1”
Console.Write("1");
public static void Thread2()
for (int i = 0; i & 1000; i++)
{//每运行一个循环就写一个“2”
Console.Write("2");
public static void dosth()
{//用来模拟复杂运算
for (int j = 0; j & ; j++)
a = a*a*a*a;
以上程序运行结果为：
从以上结果我们可以看出，t1线程所占用CPU的时间远比t2的多，这是因为t1的优先级比t2的高，若我们把t1和t2的优先级都设为Normal，结果见下：
从上例我们可看出，它的构造类似于win32的工作线程，但更加简单，只需把线程要调用的函数作为委托，然后把委托作为参数构造线程实例即可。当调用Start()启动后，便会调用相应的函数，从那函数第一行开始执行。
接下来我们结合线程的ThreadState属性来了解线程的控制。ThreadState是一个枚举类型，它反映的是线程所处的状态。当一个Thread实例刚创建时，它的ThreadState是Unstarted；当此线程被调用Start()启动之后，它的ThreadState是 R　 在此线程启动之后，如果想让它暂停(阻塞)，可以调用Thread.Sleep() 方法，它有两个重载方法(Sleep(int )、Sleep(Timespan ))，只不过是表示时间量的格式不同而已，当在某线程内调用此函数时，它表示此线程将阻塞一段时间(时间是由传递给 Sleep 的毫秒数或Timespan决定的，但若参数为0则表示挂起此线程以使其它线程能够执行，指定 Infinite 以无限期阻塞线程)，此时它的ThreadState将变为WaitSleepJoin，另外值得注意一点的是Sleep()函数被定义为了static？! 这也意味着它不能和某个线程实例结合起来用，也即不存在类似于t1.Sleep(10)的调用！正是如此，Sleep()函数只能由需“Sleep”的线程自己调用，不允许其它线程调用，正如when to Sleep是个人私事不能由它人决定。但是当某线程处于WaitSleepJoin状态而又不得不唤醒它时，可使用Thread.Interrupt 方法 ，它将在线程上引发ThreadInterruptedException，下面我们先看一个例子(注意Sleep的调用方法)：
static void Main(string[] args)
Thread t1 = new Thread(new ThreadStart(Thread1));
t1.Start();
t1.Interrupt ();
E.WaitOne ();
t1.Interrupt ();
t1.Join();
Console.WriteLine(“t1 is end”);
static AutoResetEvent E = new AutoResetEvent(false);
public static void Thread1()
{//从参数可看出将导致休眠
Thread.Sleep(Timeout.Infinite);
catch(System.Threading.ThreadInterruptedException e)
{//中断处理程序
Console.WriteLine (" 1st interrupt");
Thread.Sleep(Timeout.Infinite );
catch(System.Threading.ThreadInterruptedException e)
Console.WriteLine (" 2nd interrupt");
}//暂停10秒
Thread.Sleep (10000);
运行结果为：
1st interrupt
&2nd interrupt
&(10s后)t1 is end
从上例我们可以看出Thread.Interrupt方法可以把程序从某个阻塞(WaitSleepJoin)状态唤醒进入对应的中断处理程序，然后继续往下执行(它的ThreadState也变为Running)，此函数的使用必须注意以下几点：
1、此方法不仅可唤醒由Sleep导致的阻塞，而且对一切可导致线程进入WaitSleepJoin状态的方法(如Wait和Join)都有效。如上例所示, 使用时要把导致线程阻塞的方法放入try块内， 并把相应的中断处理程序放入catch块内。
2、对某一线程调用Interrupt, 如它正处于WaitSleepJoin状态, 则进入相应的中断处理程序执行， 若此时它不处于WaitSleepJoin状态， 则它后来进入此状态时， 将被立即中断。若在中断前调用几次Interrupt， 只有第一次调用有效, 这正是上例我用同步的原因， 这样才能确保第二次调用Interrupt在第一个中断后调用，否则的话可能导致第二次调用无效(若它在第一个中断前调用)。你可以把同步去掉试试，其结果很可能是：&& 1st interrupt
上例还用了另外两个使线程进入WaitSleepJoin状态的方法：利用同步对象和Thread.Join方法。Join方法的使用比较简单，它表示在调用此方法的当前线程阻塞直至另一线程(此例中是t1)终止或者经过了指定的时间为止(若它还带了时间量参数)，当两个条件(若有)任一出现，它立即结束WaitSleepJoin状态进入Running状态(可根据.Join方法的返回值判断为何种条件，为true，则是线程终止;false则是时间到)。线程的暂停还可用Thread.Suspend方法，当某线程处于Running状态时对它调用Suspend方法，它将进入SuspendRequested状态，但它并不会被立即挂起，直到线程到达安全点之后它才可以将该线程挂起，此时它将进入Suspended状态。如对一个已处于Suspended的线程调用则无效，要恢复运行只需调用Thread.Resume即可。
最后我们谈的是线程的销毁，我们可以对需销毁的线程调用Abort方法，它会在此线程上引发ThreadAbortException。我们可把线程内的一些代码放入try块内，并把相应处理代码放入相应的catch块内，当线程正执行try块内代码时如被调用Abort，它便会跳入相应的catch块内执行，执行完catch快内的代码后它将终止(若catch块内执行了ResetAbort则不同了：它将取消当前Abort请求，继续向下执行。所以如要确保某线程终止的最好用Join，如上例)。
二、ThreadPool
线程池(ThreadPool)是一种相对较简单的方法，它适应于一些需要多个线程而又较短任务(如一些常处于阻塞状态的线程) ，它的缺点是对创建的线程不能加以控制，也不能设置其优先级。由于每个进程只有一个线程池，当然每个应用程序域也只有一个线程池(对线)，所以你将发现ThreadPool类的成员函数都为static！ 当你首次调用ThreadPool.QueueUserWorkItem、ThreadPool.RegisterWaitForSingleObject等，便会创建线程池实例。下面就线程池当中的两函数作一介绍：
public static bool QueueUserWorkItem( //调用成功则返回true
WaitCallback callBack,//要创建的线程调用的委托
object state //传递给委托的参数
)//它的另一个重载函数类似,只是委托不带参数而已
此函数的作用是把要创建的线程排队到线程池，当线程池的可用线程数不为零时(线程池有创建线程数的限制，缺身值为25)，便创建此线程，否则就排队到线程池等到它有可用的线程时才创建。
public static RegisteredWaitHandle RegisterWaitForSingleObject(
WaitHandle waitObject,// 要注册的 WaitHandle
WaitOrTimerCallback callBack,// 线程调用的委托
object state,//传递给委托的参数
int TimeOut,//超时，单位为毫秒，
bool executeOnlyOnce file://是否只执行一次
public delegate void WaitOrTimerCallback(
object state,//也即传递给委托的参数
bool timedOut//true表示由于超时调用，反之则因为waitObject
此函数的作用是创建一个等待线程，一旦调用此函数便创建此线程，在参数waitObject变为终止状态或所设定的时间TimeOut到了之前，它都处于“阻塞”状态，值得注意的一点是此“阻塞”与Thread的WaitSleepJoin状态有很大的不同：当某Thread处于WaitSleepJoin状态时CPU会定期的唤醒它以轮询更新状态信息，然后再次进入WaitSleepJoin状态，线程的切换可是很费资源的；而用此函数创建的线程则不同，在触发它运行之前，CPU不会切换到此线程，它既不占用CPU的时间又不浪费线程切换时间，但CPU又如何知道何时运行它？实际上线程池会生成一些辅助线程用来监视这些触发条件，一旦达到条件便启动相应的线程，当然这些辅助线程本身也占用时间，但是如果你需创建较多的等待线程时，使用线程池的优势就越加明显。见下例：
static AutoResetEvent ev=new AutoResetEvent(false);
public static int Main(string[] args)
{ ThreadPool.RegisterWaitForSingleObject(
new WaitOrTimerCallback(WaitThreadFunc),
false//表示每次完成等待操作后都重置计时器，直到注销等待
ThreadPool.QueueUserWorkItem (new WaitCallback (ThreadFunc),8);
Thread.Sleep (10000);
public static void ThreadFunc(object b)
{ Console.WriteLine ("the object is {0}",b);
for(int i=0;i&2;i++)
{ Thread.Sleep (1000);
public static void WaitThreadFunc(object b,bool t)
{ Console.WriteLine ("the object is {0},t is {1}",b,t);
其运行结果为：
the object is 8
the object is 4,t is False
the object is 4,t is False
the object is 4,t is True
the object is 4,t is True
the object is 4,t is True
从以上结果我们可以看出线程ThreadFunc运行了1次，而WaitThreadFunc运行了5次。我们可以从WaitOrTimerCallback中的bool t参数判断启动此线程的原因：t为false，则表示由于waitObject，否则则是由于超时。另外我们也可以通过object b向线程传递一些参数。
它适用于需周期性调用的方法，它不在创建计时器的线程中运行，它在由系统自动分配的单独线程中运行。这和Win32中的SetTimer方法类似。它的构造为：
public Timer(
TimerCallback callback,//所需调用的方法
object state,//传递给callback的参数
int dueTime,//多久后开始调用callback
int period//调用此方法的时间间隔
// 如果 dueTime 为0，则 callback 立即执行它的首次调用。如果 dueTime 为 Infinite，则 callback 不调用它的方法。计时器被禁用，但使用 Change 方法可以重新启用它。如果 period 为0或 Infinite，并且 dueTime 不为 Infinite，则 callback 调用它的方法一次。计时器的定期行为被禁用，但使用 Change 方法可以重新启用它。如果 period 为零 (0) 或 Infinite，并且 dueTime 不为 Infinite，则 callback 调用它的方法一次。计时器的定期行为被禁用，但使用 Change 方法可以重新启用它。
在创建计时器之后若想改变它的period和dueTime，我们可以通过调用Timer的Change方法来改变：
public bool Change(
int dueTime,
int period
);//显然所改变的两个参数对应于Timer中的两参数
public static int Main(string[] args)
Console.WriteLine ("period is 1000");
Timer tm=new Timer (new TimerCallback (TimerCall),3,);
Thread.Sleep (2000);
Console.WriteLine ("period is 500");
tm.Change (0,800);
Thread.Sleep (3000);
public static void TimerCall(object b)
Console.WriteLine (" b is {0}",b);
其运行结果为：
period is 1000
period is 500
从以上的简单介绍，我们可以看出它们各自使用的场合：Thread适用于那些需对线程进行复杂控制的场合；ThreadPool适应于一些需要多个线程而又较短任务(如一些常处于阻塞状态的线程)；Timer则适用于那些需周期性调用的方法。只要我们了解了它们的使用特点，我们就可以很好的选择合适的方法。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具&&&&C#多线程编程实战(通俗易懂的C#多线程编程指南，通过70多个容易...
自营订单满49元（含）免运费
不足金额订单收取运费5元起
邀请好友参加吧
开 本：16开纸 张：胶版纸包 装：平装是否套装：否国际标准书号ISBN：8丛书名：华章程序员书库所属分类：&&&
下载免费当当读书APP
下载当当读书APP，免费阅读万本电子书。
本商品暂无详情。
当当价：为商品的销售价，具体的成交价可能因会员使用优惠券、积分等发生变化，最终以订单结算页价格为准。
划线价：划线价格可能是图书封底定价、商品吊牌价、品牌专柜价或由品牌供应商提供的正品零售价（如厂商指导价、建议零售价等）或该商品曾经展示过的销售价等，由于地区、时间的差异化和市场行情波动，商品吊牌价、品牌专柜价等可能会与您购物时展示的不一致，该价格仅供您参考。
折扣：折扣指在划线价（图书定价、商品吊牌价、品牌专柜价、厂商指导价等）某一价格基础上计算出的优惠比例或优惠金额。如有疑问，您可在购买前联系客服咨询。
异常问题：如您发现活动商品销售价或促销信息有异常，请立即联系我们补正，以便您能顺利购物。
当当购物客户端手机端1元秒
当当读书客户端万本电子书免费读&>&C#多线程复习题目80道+答案
C#多线程复习题目80道+答案
上传大小：50KB
此资源有利于初学者巩固C#多线程的基础知识，内有80道练习题及答案。
综合评分：0
{%username%}回复{%com_username%}{%time%}\
/*点击出现回复框*/
$(".respond_btn").on("click", function (e) {
$(this).parents(".rightLi").children(".respond_box").show();
e.stopPropagation();
$(".cancel_res").on("click", function (e) {
$(this).parents(".res_b").siblings(".res_area").val("");
$(this).parents(".respond_box").hide();
e.stopPropagation();
/*删除评论*/
$(".del_comment_c").on("click", function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_invalid/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parents(".conLi").remove();
alert(data.msg);
$(".res_btn").click(function (e) {
var parentWrap = $(this).parents(".respond_box"),
q = parentWrap.find(".form1").serializeArray(),
resStr = $.trim(parentWrap.find(".res_area_r").val());
console.log(q);
//var res_area_r = $.trim($(".res_area_r").val());
if (resStr == '') {
$(".res_text").css({color: "red"});
$.post("/index.php/comment/do_comment_reply/", q,
function (data) {
if (data.succ == 1) {
var $target,
evt = e || window.
$target = $(evt.target || evt.srcElement);
var $dd = $target.parents('dd');
var $wrapReply = $dd.find('.respond_box');
console.log($wrapReply);
//var mess = $(".res_area_r").val();
var mess = resS
var str = str.replace(/{%header%}/g, data.header)
.replace(/{%href%}/g, 'http://' + window.location.host + '/user/' + data.username)
.replace(/{%username%}/g, data.username)
.replace(/{%com_username%}/g, data.com_username)
.replace(/{%time%}/g, data.time)
.replace(/{%id%}/g, data.id)
.replace(/{%mess%}/g, mess);
$dd.after(str);
$(".respond_box").hide();
$(".res_area_r").val("");
$(".res_area").val("");
$wrapReply.hide();
alert(data.msg);
}, "json");
/*删除回复*/
$(".rightLi").on("click", '.del_comment_r', function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_comment_del/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parent().parent().parent().parent().parent().remove();
$(e.target).parents('.res_list').remove()
alert(data.msg);
//填充回复
function KeyP(v) {
var parentWrap = $(v).parents(".respond_box");
parentWrap.find(".res_area_r").val($.trim(parentWrap.find(".res_area").val()));
评论共有0条
VIP会员动态
CSDN下载频道资源及相关规则调整公告V11.10
下载频道用户反馈专区
下载频道积分规则调整V1710.18
spring mvc+mybatis+mysql+maven+bootstrap 整合实现增删查改简单实例.zip
资源所需积分/C币
当前拥有积分
当前拥有C币
输入下载码
为了良好体验，不建议使用迅雷下载
C#多线程复习题目80道+答案
会员到期时间：
剩余下载个数：
剩余积分：0
为了良好体验，不建议使用迅雷下载
积分不足！
资源所需积分/C币
当前拥有积分
您可以选择
程序员的必选
绿色安全资源
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
您的积分不足，将扣除 10 C币
为了良好体验，不建议使用迅雷下载
无法举报自己的资源
你当前的下载分为234。
你还不是VIP会员
开通VIP会员权限，免积分下载
你下载资源过于频繁，请输入验证码
您因违反CSDN下载频道规则而被锁定帐户，如有疑问，请联络:!
若举报审核通过，可返还被扣除的积分
被举报人：
请选择类型
资源无法下载 （ 404页面、下载失败、资源本身问题）
资源无法使用 （文件损坏、内容缺失、题文不符）
侵犯版权资源 （侵犯公司或个人版权）
虚假资源 （恶意欺诈、刷分资源）
含色情、危害国家安全内容
含广告、木马病毒资源
*投诉人姓名：
*投诉人联系方式：
*版权证明：
*详细原因：
C#多线程复习题目80道+答案分享.net技术
C#多线程详解
C#多线程编程
一、使用线程的理由
1、可以使用线程将代码同其他代码隔离，提高应用程序的可靠性。
2、可以使用线程来简化编码。
3、可以使用线程来实现并发执行。
二、基本知识
1、进程与线程：进程作为操作系统执行程序的基本单位，拥有应用程序的资源，进程包含线程，进程的资源被线程共享，线程不拥有资源。
2、前台线程和后台线程：通过Thread类新建线程默认为前台线程。当所有前台线程关闭时，所有的后台线程也会被直接终止，不会抛出异常。
3、挂起（Suspend）和唤醒（Resume）：由于线程的执行顺序和程序的执行情况不可预知，所以使用挂起和唤醒容易发生死锁的情况，在实际应用中应该尽量少用。
4、阻塞线程：Join，阻塞调用线程，直到该线程终止。
5、终止线程：Abort：抛出 ThreadAbortException 异常让线程终止，终止后的线程不可唤醒。Interrupt：抛出 ThreadInterruptException 异常让线程终止，通过捕获异常可以继续执行。
6、线程优先级：AboveNormal BelowNormal Highest Lowest Normal，默认为Normal。
三、线程的使用
线程函数通过委托传递，可以不带参数，也可以带参数（只能有一个参数），可以用一个类或结构体封装参数。
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 =
t2.IsBackground =
t1.Start();
t2.Start("hello");
Console.ReadKey();
public static void TestMethod()
Console.WriteLine("不带参数的线程函数");
public static void TestMethod(object data)
string datastr =
Console.WriteLine("带参数的线程函数，参数为：{0}", datastr);
四、线程池
由于线程的创建和销毁需要耗费一定的开销，过多的使用线程会造成内存资源的浪费，出于对性能的考虑，于是引入了线程池的概念。线程池维护一个请求队列，线程池的代码从队列提取任务，然后委派给线程池的一个线程执行，线程执行完不会被立即销毁，这样既可以在后台执行任务，又可以减少线程创建和销毁所带来的开销。
线程池线程默认为后台线程（IsBackground）。
namespace Test
class Program
static void Main(string[] args)
//将工作项加入到线程池队列中，这里可以传递一个线程参数
ThreadPool.QueueUserWorkItem(TestMethod, "Hello");
Console.ReadKey();
public static void TestMethod(object obj)
Console.WriteLine(obj.ToString());
五、Task类
使用ThreadPool的QueueUserWorkItem()方法发起一次异步的线程执行很简单，但是该方法最大的问题是没有一个内建的机制让你知道操作什么时候完成，有没有一个内建的机制在操作完成后获得一个返回值。为此，可以使用System.Threading.Tasks中的Task类。
构造一个Task&TResult&对象，并为泛型TResult参数传递一个操作的返回类型。
namespace Test
class Program
static void Main(string[] args)
Task&Int32& t = new Task&Int32&(n =& Sum((Int32)n), 1000);
t.Start();
Console.WriteLine(t.Result);
Console.ReadKey();
private static Int32 Sum(Int32 n)
Int32 sum = 0;
for (; n & 0; --n)
checked{ sum +=} //结果太大，抛出异常
一个任务完成时，自动启动一个新任务。
一个任务完成后，它可以启动另一个任务，下面重写了前面的代码，不阻塞任何线程。
namespace Test
class Program
static void Main(string[] args)
Task&Int32& t = new Task&Int32&(n =& Sum((Int32)n), 1000);
t.Start();
//t.Wait();
Task cwt = t.ContinueWith(task =& Console.WriteLine("The result is {0}",t.Result));
Console.ReadKey();
private static Int32 Sum(Int32 n)
Int32 sum = 0;
for (; n & 0; --n)
checked{ sum +=} //结果溢出，抛出异常
六、委托异步执行
委托的异步调用：BeginInvoke() 和 EndInvoke()
namespace Test
public delegate string MyDelegate(object data);
class Program
static void Main(string[] args)
MyDelegate mydelegate = new MyDelegate(TestMethod);
IAsyncResult result = mydelegate.BeginInvoke("Thread Param", TestCallback, "Callback Param");
//异步执行完成
string resultstr = mydelegate.EndInvoke(result);
//线程函数
public static string TestMethod(object data)
string datastr =
//异步回调函数
public static void TestCallback(IAsyncResult data)
Console.WriteLine(data.AsyncState);
七、线程同步
　　1）原子操作（Interlocked）：所有方法都是执行一次原子读取或一次写入操作。
　　2）lock()语句：避免锁定public类型，否则实例将超出代码控制的范围，定义private对象来锁定。
　　3）Monitor实现线程同步
　　　　通过Monitor.Enter() 和 Monitor.Exit()实现排它锁的获取和释放，获取之后独占资源，不允许其他线程访问。
　　　　还有一个TryEnter方法，请求不到资源时不会阻塞等待，可以设置超时时间，获取不到直接返回false。
　　4）ReaderWriterLock
　　　　当对资源操作读多写少的时候，为了提高资源的利用率，让读操作锁为共享锁，多个线程可以并发读取资源，而写操作为独占锁，只允许一个线程操作。
　　5）事件（Event）类实现同步
　　　　事件类有两种状态，终止状态和非终止状态，终止状态时调用WaitOne可以请求成功，通过Set将时间状态设置为终止状态。
　　　　1）AutoResetEvent（自动重置事件）
　　　　2）ManualResetEvent（手动重置事件）
　　6）信号量（Semaphore）
　　　　　　信号量是由内核对象维护的int变量，为0时，线程阻塞，大于0时解除阻塞，当一个信号量上的等待线程解除阻塞后，信号量计数+1。
　　　　　　线程通过WaitOne将信号量减1，通过Release将信号量加1，使用很简单。
　　7）互斥体（Mutex）
　　　　　　独占资源，用法与Semaphore相似。
　 8）跨进程间的同步
　　　　　　通过设置同步对象的名称就可以实现系统级的同步，不同应用程序通过同步对象的名称识别不同同步对象。
C#多线程操作的学习
C#多线程整理
c#使用多线程的几种方式示例详解
C# 开启线程几种方式
C#多线程编程（1）：线程的启动
C#多线程（Thread）开发基础
CSharp学习笔记之九 多线程编程
C#中的多线程编程
没有更多推荐了，