【正文】 單元格是滿的，然后刪除，并返回其內(nèi)容： public class OneCell { public OneCell() { empty()。 private async empty() { contains(o)。 private async contains(object o) { empty()。 } } 在另外兩個(gè)公共方法，類使用兩個(gè)私人異步方法， empty()和 contains(object o)，進(jìn)行單元格的狀態(tài)。當(dāng)一個(gè)細(xì)胞被創(chuàng)建，它是最初是空的（ ）。如果我們把一個(gè)單元格是一個(gè)空的（）對象，然后單元格隨后包含（ O）。如果我們獲得（）單元格的內(nèi)容，然后包含一個(gè)空的對象，返回值是 o。在所有其他情況下，提出并獲取等待。觀察到的構(gòu)造 建立，每在類 OneCell 身體保留，簡單，易于驗(yàn)證不變： 總是有一個(gè)掛起的異步方法調(diào)用：無論是 empty()，或 contains(o)。），因此也可以作為直接讀取類定義一個(gè)自動(dòng)的規(guī)范： 9 讀寫鎖 作為一個(gè)異步方法的使用進(jìn)行狀態(tài)更現(xiàn)實(shí)的例子和同步訪問該狀態(tài)的和弦，我們現(xiàn)在考慮的經(jīng)典問題多的讀者，作家單鎖保護(hù)共享的易變的資源。沒有其他共享訪問塊的請求，直到客戶端具有獨(dú)占訪問，同時(shí)請求，直到?jīng)]有獨(dú)占訪問塊其他客戶端有任何訪問。和弦 199。} public void Shared() amp。 } public void Shared() amp。 } public void ReleaseShared() amp。 else s(n ? 1)。 async idle() {} public void ReleaseExclusive() { idle()。萬一有一個(gè)消息，等候在一個(gè)給定的私有方法，它是一個(gè)選擇的問題，是否使用私有字段的對象或參數(shù)在私人訊息。盡管如此，相反，我們可以編寫以下等效的代碼： class ReaderWriterPrivate { } ReaderWriter() { idle()。 // protected by s() public void Shared() amp。 s()。 async s() { n++。 } public void ReleaseShared() amp。 else s()。 async idle() {} public void ReleaseExclusive() { idle()。因此，它是非常有用的一些明確具體公平或優(yōu)先的額外的應(yīng)用程序編程。我們進(jìn)一步完善這個(gè)代碼來實(shí)現(xiàn)一個(gè)特定的公平當(dāng)有掛起的編寫者，至少 讀者和編寫者之間：一位編寫者，將獲得目前所有的讀者釋放它的鎖。 async t() { if (??n == 0) idleExclusive()。 } public void Exclusive() amp。 wait()。 async idleExclusive() {} 合并異步消息 消息傳遞通常會(huì)由服務(wù)器的外部接口，使用異步方法，每個(gè)參數(shù)都需要參數(shù)的請求和發(fā)送請求已經(jīng)服務(wù)的最終結(jié)果或通知的地方。 public class Service { public async Request(string arg, IntCallback cb) { int r 。 // send the result back } } 一種常見的客戶端模式，然后涉及到幾個(gè)并發(fā)的異步請求后阻塞直到所有已完成。 public IntCallback secondcb。 secondcb = new IntCallback(second)。 async ?rst(int fst) amp。 j = snd。 Service s2 = . . . 。 (args*0+, x . ?rstcb)。 ... int i, j 。 } 11 } ... 在到 通話（ I， J）將阻止，直到 /除非服務(wù)已回答 x 上調(diào)用各自的回調(diào)。概括注冊（當(dāng)然，自然屬于通用庫）任意同時(shí)通 話，或定義類的條件，如等待至少 35 通話已完成很簡單的。 Gosling et al. 1996。 Gurevich et al. 2020] to the point where one can usually determine what their behaviour should be under any Implementation. Yet, even when the concurrency libraries are satisfactorily speci?ed, 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 memory management and exceptions. The advantage of having such features “in the language” is that the piler can analyze them, and can therefore produce better code and warn programmers of potential and actual problems. In particular, the piler can check for syntactically embedded invariants that would be dif?cult 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 piler can more easily determine the programmers? intentions. Domain Speci?c Languages [Ramming 1997。 Agha et al. 1993。 Pierce and Turner 2020。 at the same time, users hate being blocked unnecessarily. At the wide area work level, for example in collaborative applications, distributed work?ow, or web services, we are now experiencing similar problems and plexity because of the asynchronous nature and latencies of global munication. 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 can somewhat hide the use of messages and threads behind a language mechanism, then many options bee possible. A piler 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, and 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 asynchronous 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 piler and runtime systems. We propose an extension of the C language with modern concurrency abstraction for asynchronous programming. In tune with the musical spirit of C and with the “orchestration” of concurrent activities, we call this language Polyphonic C .1 C and .NET C is a modern, type safe, object oriented programming language recently introduced by Microsoft as part of Visual [ECMA 2020]. C programs run on top of the .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 lock statement, which obtains the mutex associated with a given object during the execution of a block. In addition, the .NET libraries implement many traditional 13 concurrency control primitives such as semaphores, mutexes and reader/writer locks, as well as an asynchronous programming model based on The .NET Polyphony is musical position that uses simultaneous, largely independent, melodic parts, lines, or voices (Encarta World English Dictionary, Microsoft Corporation, 2020). 2An instance of a delegate class encapsulates an object and a method on that object with a particular signature. So a delegate is more than a C style function pointer, but slightly less than a closure. Framework also provides higher level infrastructure for building distributed applications and services, such as SOAP based messaging and remote method call. The concurrency and distribution mechanisms of the .NET Framework are powerful, but they are also undeniably plex. Quite apart from the bewildering array of primitives that are more or less