计算机毕业设计外文翻译现代并发抽象C＃

1、南京邮电大学毕业设计(论文)外文资料翻译学 院传媒与艺术学院专业数字媒体技术学生姓名黄超班级学号b080705 b08070525外文出处acm transactions on programming languages and systems, vol. 26, no. 5, september 2004附件：1.外文资料翻译译文；2.外文原文指导教师评价：1翻译内容与课题的结合度： 优 良 中 差2翻译内容的准确、流畅： 优 良 中 差3专业词汇翻译的准确性： 优 良 中 差4翻译字符数是否符合规定要求： 符合 不符合指导教师签名：年月日附件1：外文资料翻译译文现代并发抽象c尼克本顿，卢卡

2、卡戴尔和塞德里克富尔微软研究院1.1语言和并发并发是现代代码中的一个重要实现形式：并发程序的编写设计，解释，调试，和调整都是有难度的。并发可以显著影响一个结构中的语言的含义（开始转让的原子），并能影响调用库的能力。尽管这样，最流行的编程语言对待并发语言不是作为一种语言功能的并发性，而往往是作为一个收集的，根据指定的外部库。考虑到这样的事实后，规范的并发库比勒尔等。 1987年;斯林等。 1996年detlefs等。 1998年古列维奇等。 2000 已给予相当的重视，通常通过这些规范就可以对他们的行为应该在何处执行做出判断。然而，即使当并发库被正确指定，但由于他们是库，而不是语言的特点这个事实

3、，还是会有不良的后果。在原则上，可以提供许多功能，无论是作为语言特性或作为库：典型的例子是，内存管理和异常。有“语言”等功能的优点是，编辑者可以对它们进行分析，因此可以产生更好的代码，并警告亲程序员的潜在和实际问题。特别是，编译器可以检查语法嵌入的变量，这将是很难从库中提取调用的集合。此外，程序员可以更可靠说明自己的意图，通过一个清晰的语法和其他工具比编辑者可以更容易地确定程序员的意图。特定领域的语言ramming 1997; kamin 1997是一个极端的语言学方法的例子：经常提出新的特设语言并不是要取代通用的语言，而是为了方便特定于域的代码分析域相关的功能，作为原始的语言表达简单的事实结

4、构。我们相信，并发应该是一个语言功能的一部分和一种语言规范。在70年代开始在这个方向作了很多尝试，显示器霍尔1974年的概念和奥卡姆语言inmos有限公司1984（基于通信顺序进程霍尔1985）。监控器的一般概念已经变得非常流行，特别是在其目前的面向对象的形式线程和对象绑定互斥，但它已提供作为一个语法的外壳模板，最可选锁定对象上的方法调用。许多事情因为监控器被引入并发而已经改变。通信已变得更加的异步，并行计算一定要通过规模较大的“精心策划”的。值得关注的是没有那么多的有效的实施和使用锁在一个单一的处理器或者多重处理器，但没有不必要的异步事件的处理能力阻止长期客户，并没有死锁。换句话说，重心正在

5、从共享内存并发转向消息或事件并发性。这些新的要求应该得到可以处理异步通信和不束缚共享记忆的编程结构的方法。尽管出现大规模的模式设计如america 1989; agha et al.1993; reppy 1992; pierce and turner 2000; philippsen 1995，但只有监控器获得广泛接受的编程结构。最近在富尔和gonthier的1996，2002加入演算中显现了一个有趣的新的语言方法，进程演算非常适合在分布式的环境中直接执行。其他语言，如jocaml conchon and le fessant 1999和 funnel odersky 2000，结合了类似功

6、能编程模型的想法。在这里，我们提出了一个加入演算想法的适应一个面向对象的语言，有一个现有线程和锁的并发模型。 itzstein和kearney 2001最近为java描述非常类似的扩展。1.2异步编程异步的事件和消息传递越来越多地用于在各级软件系统。在最低水平，设备驱动程序必须对异步设备事件迅速作出反应，而资源利用上的吝啬。在图形用户界面级别是出了名的，复杂的代码和编程模型，因为用户事件的异步性质;在同一时间，用户讨厌被不必要的封锁。在广域网的水平，例如，在协作应用，分布式的工作流，web服务，我们现在遇到类似的问题，因为全球通信的异步性质和潜伏期和复杂性。在所有这些领域，我们自然会发现有很多

7、要处理的同时异步消息的情况下，多线程用来处理它们。主题仍然是一个在大多数系统中昂贵的资源。然而，如果我们能有些隐藏在背后的消息和线程使用一种语言机制，那么很多的选项成为可能。编译器可状态机转换成并发的一些模式，优化使用队列，使用轻量级的线程，在可能的情况下，避免分叉线程没有必要的，并使用线程池。这一切都是真的有可能只有一个拥有上谱“，可以发生的事情”：这个手柄可以处理由并发操作，既可以隐藏，从而使多个语法实现技术。因此，我们的目标是促进异步编程抽象是高层次的，从一个程序员的角度来看，使低层次的优化，从一个编译器和运行时系统的角度来看。我们提出用现代并发c语言的延伸异步编程抽象。在与音乐的精神调

8、谐的c和并发活动的“协调流程”，我们称这种语言复调c。1.3 c# 和 .netc是一个现代，类型安全，面向对象编程语言，最近微软推出的visual studio.net2001ecma的一部分。 c程序上运行.net框架，其中包括多语言的执行顶部引擎和一个丰富的类库集合。.net执行引擎提供了一个多线程的执行环境潜在的相互关联与同步锁ment在堆上分配的对象。c语言，包括一个lock语句，执行的过程中获得一个给定的对象相关联的互斥阻塞。此外，.net库实现了许多传统的并发控制原语，如信号量，互斥和读/写锁，以及异步编程模型的基础上代表。.net框架还提供更高级别的基础设施建设分布应用和服务，

9、如基于soap的消息传递和远程方法打电话。.net framework中的并发和分配机制功能强大，但他们也不可否认复杂。且不说从原语，更多的或较少的基础设施，在烤“让人眼花缭乱，有一台机器上（共享内存，线程，同步的基础上的东西是20世纪70年代的并发模型之间的不匹配相互排斥）和异步，基于消息的风格，使用编程基于网络的应用和服务。因此，c中似乎是一个为主流的并发语言支持我们的想法，理想的测试床语言。2。复调c语言概述本节介绍新构造复调的c语法和语义，然后给出了更精确，虽然仍是非正式的，规范语法。 2.1基本思路到c的相当传统的面向对象编程模型，复调c增加了两个新概念：异步方法和复调。异步方法。传

10、统的方法是同步的，在检测到来电者没有取得任何进展，直到被叫方完成。复调c中，如果一个方法被声明为异步调用任何保证立即基本上完成。异步方法永远不会返回结果（或抛出异常）;他们使用async关键字，而不是宣布无效。调用异步方法很像是发送消息，或张贴的事件。由于异步方法立即返回，方法的调用如下: async postevent(eventinfo data) / large method body是唯一可以合理地调用立即返回，“大被安排在不同的线程执行方法体“（无论是一个新的催生了以服务这个呼叫，或者从一些游泳池的工人）。然而，这样的定义，实际上是相当难得的c复调。更常见的异步方法是使用如下所述的复

11、调，定义，不一定需要新的线程。复调。复调（也被称为“同步模式”，或“加盟模式”）由一个头和一个身体。头是一套方法声明由“”分隔。身体只执行一次所有的方法，在头被称为方法调用隐含排队等候，直到/除非是有现代并发抽象为c匹配的复调。考虑，例如:public class buffer public string get() & public async put(string s) return s;上面的代码定义了两个实例方法的类的缓冲区，这是共同定义在一个单一的复调。string get()方法是一个同步的方法不接受参数并返回一个字符串。async put(string s)方法是异步的（没有返回

12、结果），并接受一个字符串参数。如果buff是缓冲和一个调用同步方法的的一个buff . get()实例。然后有两种可能性： 如果有以前的未匹配过的的通话buff . put(s) (for some string s)，那么现在有一个比赛，所以离队待沽put(s)和复调的身体运行，返回到呼叫者的buff . get()方法。 如果是以前匹配过的来电buff . put(.)，然后调用buff. get（）方法阻塞，直到另一个线程提供了一个匹配的put（）。相反，在调用异步方法的buff . put(.)，来电从未等待，但对于其他线程可能有两种行为： 如果有以前的未匹配过的通话buff . ge

13、t()再有就是现在的一次匹配，所以挂起调用出列和其相关阻塞的线程是唤醒运行的复调，返回值给s。 如果没有挂起调用的buff.get（），然后调用到buff . put(s)仅仅是排队，直到一个个到达。到底哪的电话匹配是不确定的，所以即使是单线程程序如：buffer buff = new buffer();buff . put(“blue”);buff . put(“sky”);console.write(buff . get() + buff . get();也是不确定的（印刷或者“蓝天”或“天蓝”）。请注意，执行缓冲不涉及产生任何主题：复调本身在运行时，它在一个已经存在的线程（即一个名为ge

14、t()）。读者在这一点上可能会想什么规则决定在哪个线程体运行，或如何，我们知道，方法调用将返回人体所计算的最终价值。答案是，在任何给定的弦，最多的一种方法可能是同步的。如果有这种方法，然后身体在与调用线程运行这一号召的方法，并返回值。只是，如果没有这样的方法（即在弦的所有方法都是异步）运行在一个新的线程，在这种情况下，有没有要返回的值。还应当指出，缓冲区的代码，琐碎，但它是，是线程安全的。需要锁定（例如，以防止参数返回两个不同的获取到一个单放）自动生成由编译器。更确切地说，决定是否任何复调呼叫启用，如果是这样，从队列中删除其他悬而未决的呼叫和调度为执行机构，是一个原子操作。除了这个原子性的保证

15、，然而，有没有监视器像复调机构之间的相互排斥的。任何相互排斥的需要，必须明确在编程在弦头的同步条件。缓冲区的例子定义了两个方法使用一个单一的复调。这也是（普通）有涉及给定方法的多复调。例如：public class buffer public string get() & public async put(string s) return s;public string get() & public async put(int n) return n.tostring(); 现在我们已经定义为数据缓冲区的方法之一，但有两个把它的方法（其中发生类型，而不是要区分比名）。get()调用可以同步调用

16、的put（）方法。如果有排队调用put()s，那么哪一个同步随后get()是不确定的。3。非正式规范3.1语法到c语法的语法扩展ecma 2001, appendix c是非常次要的。我们添加一个新的关键字async，并添加它作为一种替代的返回类型：returntype : := type | void | async这使得方法，代表和接口方法被宣布异步的。在类成员的声明中，我们更换方法声明chorddeclaration : :=methodheader & methodheader bodymethodheader : :=属性修饰符返回类型成员名（形参）。我们呼吁复调声明微不足道的，如果

17、它宣布一个单一的，同步的方法（即它是一个标准的c方法声明）。3.2良好的格式扩展类是格式良好的条件： 在一个单一的方法头：（1）如果返回类型是异步的，那么正式的参数列表中的形参不得包含任何ref或out参数修饰符。 在一个单一的复调声明：（2）最多的一种方法头可能有非异步的返回类型。（3）如果弦有一个返回类型的类型的方法头，然后身体可能使用返回类型的表达式的语句，否则身体可能使用空的return语句。（4）在方法头中出现的所有形参必须有鲜明的标识。（5）两种方法，头可能没有相同的成员名称和相同的参数类型签名。（6）的方法，头必须全部申报的实例方法或所有声明的静态方法。 在一个特定的类：（7）具

18、有相同的成员名称和参数类型的所有方法头签名必须具有相同的属性的返回类型和相同的套和修饰符。（8）如果它是一个值类（结构），那么只有静态方法可能会出现在不平凡的复调。（9）如果任何复调声明包括一个覆盖虚拟方法m修饰符，那么任何方法n出现在包含重写定义的m的超弦与m也必须被重写在子类中。这些条件大多是相当简单的，但条件2和9值得我们进一步的评论。条件9提供了一个保守的，但简单，完整性检查时，炼油类包含复调以来，在一般情况下，实现继承和并发不拌匀松冈和米泽1993（见富尔等。 2000连接的情况下讨论了“继承异常”微积分）。这里是我们的方法来执行这两个关注点分离：一系列的复调，必须是当地的一类或子类

19、声明的语法;方法重写时，他们所有的复调还必须完全重写。如果认为执行一个给定的方法包括所有同步和机构，它出现的所有的复调，那么，我们继承的限制似乎不是没有道理的，因为在（非法）代码，如class c virtual void f () & virtual async g () / body1 / virtual void f () & virtual async h() / body2 / class d : c override async g () / body3 / 一个会覆盖g（），也有“一半”重写f（）。更务实的态度，消除对继承的限制，使得这一切太容易引入无意僵局（或“异步泄漏”）。如

20、果上面的代码是合法的，那么代码编写的期望，使匹配的c类的实例f（）和g（）的调用将无法工作时，通过d 所有的实例g（）的调用会导致body3运行，所有的调用f（）的僵局。请注意，在继承的限制手段，如声明virtual void f () & private async g () / body1 / 是不正确的声明只是一个f（）和g（）是虚拟的，是没有意义的（是作为我们的编译器的错误标记），作为压倒一切的要求其他要重写了。这也是值得观察，有一个传递闭包操作隐含在我们继承的限制：如果f（）是重写，并加入与g（），然后因为g（）必须被覆盖，所以必须任何方法h（）加入与g（）等。 制定重写规则更加复杂

21、和宽容是有可能的。我们的目前的规则有简单的优势，但我们指的读者富尔等。 2000为更深入的研究在继承和并发加入演算。在该文件中，类（部分）同步的集合可以使用一些继承运营商结合和转化的模式。像往常一样，然后创建对象可以实例化类，同步模式是不可扩展的。类的组成控制一个复杂的的打字纪律，防止“消息不理解为“在运行时的错误。格式良好上述条件2也是合理的，由现有的c#功能和纯加入演算之间的潜在的不良相互作用。允许多个同步调用出现在一个单一的复调会给一种潜在的有用的交会设施（提供一个也加入语法允许特定的调用返回结果）。例如，以下的实例类： class rendezvous public int f (in

22、t i) & public int g (int j ) return j to f ;return i to g ;将匹配的双f和g的调用，然后交换它们的值并继续。然而，也必须决定在封锁线程机构应运行，这样的选择一般观察。如果这只因为线程的身份可以得到平等检查，这个问题将是相当学术。但是，在c#，选择线程做一个方案由于到折返锁，基于堆栈的安全性和线程局部变量，从而使行为的显着性差异“非常”非交换。当然，这也不是很难明确方案复调c#上述交会：class rendezvous class thunk int wait() & async reply(int j ) return j ;publi

23、c int f (int i) thunk t = new thunk();af (i, t);return t.wait();private async af (int i, thunk t) & public int g (int j ) t . reply( j ); / returning to freturn i; / returning to g对于每个调用到f，我们创建了一个辅助类咚的实例，为了等待异步答复消息，这是同步后发送一些。3.3打字问题我们把async作为一个无效的亚型，并允许异步协变返回类型，只是在这两个类型（伪）的情况下。从而 一个异步方法可以覆盖一个void类型，

24、 委托void类型，可以创建一个异步方法， 一个异步方法可以实现一个接口void方法而不是相反。这种设计使得直观的感觉（异步方法无效，但有额外的属性返回“立即”），并最大限度地使用现有的c#代码（父类，接口和兼容性委托的定义）的无效使用。4。复调c#的编程在介绍语言，我们现在怎么可能被用来解决并发编程问题的范围。4.1一个简单的细胞类我们先从一个简单的地方细胞类的实现。单元格有两种公共同步方法：void put(object o) 和 object get()。把呼叫块，直到单元格是空的，然后用它的参数填充单元。一个调用获取块，直到单元格是满的，然后删除，并返回其内容：public class

25、 onecell public onecell() empty();public void put(object o) & private async empty() contains(o);public object get() & private async contains(object o) empty();return o; 在另外两个公共方法，类使用两个私人异步方法，empty()和contains(object o)，进行单元格的状态。有一个简单的声明构造和解释两个和弦这是如何工作：构造。当一个细胞被创建，它是最初是空的（）。输出和弦。如果我们把一个单元格是一个空的（）对象，然后

26、单元格随后包含（o）。获取和弦。如果我们获得（）单元格的内容，然后包含一个空的对象，返回值是o。含蓄。在所有其他情况下，提出并获取等待。使用私人异步方法（而不是域）的技术携带状态是很常见的和弦的c。观察到的构造建立，每在类onecell身体保留，简单，易于验证不变：总是有一个挂起的异步方法调用：无论是empty()，或contains(o)。（相反可能有任意数量的客户端线程阻塞与挂起的调用，把获取，甚至同时运行的语句返回0到之前的变量体。），因此也可以作为直接读取类定义一个自动的规范：4.2读写锁作为一个异步方法的使用进行状态更现实的例子和同步访问该状态的和弦，我们现在考虑的经典问题多的读者，

27、作家单锁保护共享的易变的资源。每个客户的要求，然后释放，要么共享访问或独占访问，使用相应的共享的公共方法，释放共享，独家，释放独占。没有其他共享访问块的请求，直到客户端具有独占访问，同时请求，直到没有独占访问块其他客户端有任何访问。一个典型的解决这个问题，使用传统的并发原语在modula3给出由，比勒尔1989;和弦，它可以只有五和弦：class readerwriterreaderwriter() idle();public void shared() & async idle() s(1); public void shared() & async s(int n) s(n + 1); p

28、ublic void releaseshared() & async s(int n) if (n = 1) idle(); else s(n 1);public void exclusive() & async idle() public void releaseexclusive() idle(); 每一个版本如下规定相应的要求，不变是锁状态（没有消息，一条消息空闲（），或单线程的种类和数量相匹配，目前消息小号n 0（n）持有该锁（独家线程，没有线程，或n共享的线程）。万一有一个消息，等候在一个给定的私有方法，它是一个选择的问题，是否使用私有字段的对象或参数在私人讯息。在上面的例子中，n是

29、有关的，只有当有消息中的（）。尽管如此，相反，我们可以编写以下等效的代码：class readerwriterprivate readerwriter() idle(); private int n = 0; / protected by s()public void shared() & async idle() n = 1; s(); public void shared() & async s() n+; s(); public void releaseshared() & async s() if (n = 0) idle(); else s();public void exclusi

30、ve() & async idle() public void releaseexclusive() idle(); 仅我们的执行和底层操作系统调度提供基本的公平属性例如：如果有足够的等候和弦对象的调用匹配一个和弦，那么至少有一个和弦最终会运行。因此，它是非常有用的一些明确具体公平或优先的额外的应用程序编程。例如，上面的代码，编写者未必能够获得新的读者只要独占锁获得一个共享锁。我们进一步完善这个代码来实现一个特定的公平当有挂起的编写者，至少读者和编写者之间：一位编写者，将获得目前所有的读者释放它的锁。为此，我们增加额外的共享状态：t（），我们不接受新的读者，idleexclusive（），在我

31、们所提供的独占锁以前选择主题：class readerwriterfair. . . / same content as in readerwriterprivate, plus:public void releaseshared() & async t() if (n = 0) idleexclusive(); else t();public void exclusive() & async s() t(); wait(); void wait() & async idleexclusive() 4.3合并异步消息消息传递通常会由服务器的外部接口，使用异步方法，每个参数都需要参数的请求和发送

32、请求已经服务的最终结果或通知的地方。例如，回调使用一个字符串参数，服务代表，并返回一个整数，看起来类似于：public delegate async intcallback(int result);public class service public async request(string arg, intcallback cb) int r ;. . . / do some workcb(r); / send the result back 一种常见的客户端模式，然后涉及到几个并发的异步请求后阻塞直到所有已完成。这可以编程如下：class join2 public intcallback

33、 rstcb;public intcallback secondcb;public join2() rstcb = new intcallback(rst);secondcb = new intcallback(second);public void wait(out int i, out int j )& async rst(int fst)& async second(int snd) i = fst; j = snd;class client public static void main(string args) service s1 = . . . ;service s2 = . .

34、 . ;join2 x = new join2();s1.request(args0, x . rstcb);s2.request(args1, x . secondcb);.int i, j ;x.wait(out i, out j ); .在到x.wait通话（i，j）将阻止，直到/除非服务已回答x上调用各自的回调。一旦发生这种情况，两结果将被分配到i和j，客户端将继续进行。概括注册（当然，自然属于通用库）任意同时通话，或定义类的条件，如等待至少35通话已完成很简单的。附件2：外文原文modern concurrency abstractions for c#nick benton, lu

35、ca cardelli, and cedric fournetmicrosoft research1. introduction1.1languages and concurrencyconcurrency is an important factor in the behaviour and performance of modern code: concurrent programs are difcult to design, write, reason about, debug, and tune. concurrency can signicantly affect the mean

36、ing of virtually every other construct in the language (beginning with the atomicity of assignment), and can affect the ability to invoke libraries. despite this, most popular pro gramming languages treat concurrency not as a language feature, but as a collection of external libraries that are often

37、 underspecied. considerable attention has been given, after the fact, to the specication of important concurrency libraries birrell et al. 1987; gosling et al. 1996; detlefs et al. 1998; gurevich et al. 2000 to the point where one can usually determine what their behaviour should be under any implem

38、entation. yet, even when the concurrency libraries are satisfactorily specied, the simple fact that they are libraries, and not features of the language, has undesirable consequences. many features can be provided, in principle, either as language features or as libraries: typical examples are memor

39、y management and exceptions. the advantage of having such features “in the language” is that the compiler can analyze them, and can therefore produce better code and warn programmers of potential and actual problems. in particular, the compiler can check for syntactically embedded invariants that wo

40、uld be difcult to extract from a collection of library calls. moreover, programmers can more reliably state their intentions through a clear syntax, and tools other than the compiler can more easily determine the programmers intentions. domain specic languages ramming 1997; kamin 1997 are an extreme

41、 example of this linguistic approach: new adhoc languages are routinely proposed not to replace general purpose language, but to facilitate domain specic code analysis by the simple fact of expressing domain related features as primitive language constructs. we believe that concurrency should be a l

42、anguage feature and a part of language specications. serious attempts in this direction were made beginning in the 1970s with the concept of monitors hoare 1974 and the occam language inmos limited 1984 (based on communicating sequential processes hoare 1985). the general notion of monitors has beco

43、me very popular, particularly in its current object oriented form of threads and object bound mutexes, but it has been provided at most as a veneer of syntactic sugar for optionally locking objects on method calls. many things have changed in concurrency since monitors were introduced. communication

44、 has become more asynchronous, and concurrent computations have to be “orchestrated” on a larger scale. the concern is not as much with the efcient implementation and use of locks on a single processor or multiprocessor, but with the ability to handle asynchronous events without unnecessarily blocki

45、ng clients for long periods, and without deadlocking. in other words, the focus is shifting from shared memory concurrency to message or event oriented concurrency. these new requirements deserve programming constructs that can handle asynchronous communications well and that are not shackled to the

46、 shared memory approach. despite the development of a large collection of design pat terns lea 1999 and of many concurrent languages america 1989; agha et al. 1993; reppy 1992; pierce and turner 2000; philippsen 1995, only monitors have gained widespread acceptance as programming constructs. an inte

47、resting new linguistic approach has emerged recently with fournet and gonthiers 1996, 2002 join calculus, a process calculus well suited to direct implementation in a distributed setting. other languages, such as jocaml conchon and le fessant 1999 and funnel odersky 2000, combine similar ideas with

48、the functional programming model. here we propose an adapta tion of join calculus ideas to an object oriented language that has an existing thread sand locks concurrency model. itzstein and kearney 2001 have recently described very similar extensions for java. 1.2asynchronous programming asynchronou

49、s events and message passing are increasingly used at all levels of software systems. at the lowest level, device drivers have to respond promptly to asynchronous device events, while being parsimonious on resource use. at the graphical user interface level, code and programming models are notorious

50、ly complex because of the asynchronous nature of user events; at the same time, users hate being blocked unnecessarily. at the wide area network level, for example in collaborative applications, distributed workow, or web services, we are now experiencing similar problems and complexity because of t

51、he asynchronous nature and latencies of global communication. in all these areas, we naturally nd situations where there are many asynchronous messages to be handled concurrently, and where many threads are used to handle them. threads are still an expensive resource on most systems. however, if we

52、can somewhat hide the use of messages and threads behind a language mechanism, then many options become possible. a compiler may transform some patterns of concurrency into state machines, optimize the use of queues, use lightweight threads when possible, avoid forking threads when not necessary, an

53、d use thread pools. all this is really possible only if one has a handle on the spectrum of “things that can happen”: this handle can be given by a syntax for concurrent operations that can both hide and enable multiple implementation techniques. therefore, we aim to promote abstractions for asynchr

54、onous programming that are high level, from the point of view of a programmer, and that enable low level optimizations, from the point of view of a compiler and runtime systems. we propose an extension of the c# language with modern concurrency abstraction for asynchronous programming. in tune with

55、the musical spirit of c# and with the “orchestration” of concurrent activities, we call this language polyphonic c# .1 1.3c# and .net c# is a modern, type safe, object oriented programming language recently introduced by microsoft as part of visual studio.net ecma 2001. c# programs run on top of the

56、 .net framework, which includes a multilanguage execution engine and a rich collection of class libraries. the .net execution engine provides a multithreaded execution environment with synchronization based on locks potentially associated with each heapal located object. the c# language includes a l

57、ock statement, which obtains the mutex associated with a given object during the execution of a block. in addition, the .net libraries implement many traditional concurrency control primitives such as semaphores, mutexes and reader/writer locks, as well as an asynchronous programming model based on delegates.2 the .n