🚨 🙆🏿 👌🏾 C # में Async / प्रतीक्षा करें: अवधारणा, आंतरिक डिज़ाइन, उपयोगी ट्रिक्स 🤵🏼 🤶🏼 🌩️

शुभ दिन। इस बार हम एक ऐसे विषय के बारे में बात करेंगे जो C # भाषा के प्रत्येक स्वाभिमानी अनुयायी को समझ में आने लगा - टास्क का उपयोग करके अतुल्यकालिक प्रोग्रामिंग, या आम लोगों में, async / प्रतीक्षा। Microsoft ने एक अच्छा काम किया - ज्यादातर मामलों में अतुल्यकालिक का उपयोग करने के लिए आपको केवल सिंटैक्स और कोई अन्य विवरण जानने की आवश्यकता है। लेकिन अगर आप गहराई में जाते हैं, तो विषय काफी बड़ा और जटिल है। यह कई, प्रत्येक ने अपनी शैली में कहा था। इस विषय पर बहुत सारे अच्छे लेख हैं, लेकिन अभी भी इसके बारे में बहुत सारी गलत धारणाएँ हैं। हम स्थिति को सही करने की कोशिश करेंगे और जितना संभव हो उतना गहराई या समझ का त्याग किए बिना सामग्री को चबा सकते हैं।

विषय / अध्याय कवर:

अतुल्यकालिक की अवधारणा - एक "अवरुद्ध" धागे के बारे में अतुल्यकालिक और मिथकों का लाभ
नल। सिंटेक्स और संकलन की स्थिति - एक संकलन विधि लिखने के लिए आवश्यक शर्तें
TAP के उपयोग के साथ काम करें - अतुल्यकालिक कोड में मैकेनिक्स और प्रोग्राम का व्यवहार (थ्रेडिंग मुक्त करना, कार्य शुरू करना और उन्हें पूरा करने के लिए इंतजार करना)
पर्दे के पीछे: राज्य मशीन - संकलक परिवर्तनों और इसे उत्पन्न करने वाले वर्गों का अवलोकन
अतुल्यकालिक की उत्पत्ति। मानक अतुल्यकालिक विधियों का उपकरण - फाइलों और अंदर से नेटवर्क के साथ काम करने के लिए अतुल्यकालिक तरीके
टीएपी कक्षाएं और ट्रिक्स उपयोगी ट्रिक्स हैं जो आपको टीएपी का उपयोग करके प्रोग्राम को प्रबंधित करने और गति प्रदान करने में मदद कर सकती हैं

अतुल्यकालिक अवधारणा

अपने आप में अतुल्यकालिकता नए से बहुत दूर है। अतुल्यकालिक आमतौर पर एक ऐसी शैली में एक ऑपरेशन करने का अर्थ है जो कॉलिंग थ्रेड को अवरुद्ध नहीं करता है, अर्थात, इसके पूरा होने की प्रतीक्षा किए बिना ऑपरेशन शुरू करना। अवरुद्ध करना उतना बुरा नहीं है जितना कि इसका वर्णन किया गया है। कोई भी दावा कर सकता है कि अवरुद्ध थ्रेड्स CPU समय बर्बाद करते हैं, अधिक धीरे-धीरे काम करते हैं और बारिश का कारण बनते हैं। क्या बाद वाली संभावना कम लगती है? वास्तव में, पिछले 2 अंक समान हैं।

ओएस अनुसूचक स्तर पर, जब एक थ्रेड "अवरुद्ध" स्थिति में होता है, तो कीमती प्रोसेसर समय इसे आवंटित नहीं किया जाएगा। शेड्यूलर कॉल, एक नियम के रूप में, उन कार्यों पर गिरती है जो अवरुद्ध होने का कारण बनते हैं, टाइमर बाधित होता है, और अन्य व्यवधान होते हैं। यही है, जब, उदाहरण के लिए, डिस्क नियंत्रक रीड ऑपरेशन को पूरा करता है और एक उचित व्यवधान शुरू करता है, शेड्यूलर शुरू होता है। वह यह तय करेगा कि इस ऑपरेशन द्वारा अवरुद्ध किए गए धागे को शुरू करना है या उच्च प्राथमिकता वाले किसी अन्य को।

धीमा काम और भी बेतुका लगता है। वास्तव में, वास्तव में, काम एक और एक ही है। केवल एसिंक्रोनस ऑपरेशन थोड़ा अधिक ओवरहेड जोड़ देगा।

बारिश की चुनौती आम तौर पर इस क्षेत्र से कुछ नहीं है।

मुख्य अवरुद्ध समस्या कंप्यूटर संसाधनों की अनुचित खपत है। यहां तक कि अगर हम एक धागा बनाने के लिए समय के बारे में भूल जाते हैं और थ्रेड्स के पूल के साथ काम करते हैं, तो प्रत्येक अवरुद्ध धागा अतिरिक्त स्थान का उपभोग करता है। वैसे, ऐसे परिदृश्य हैं जहां केवल एक धागा कुछ काम कर सकता है (उदाहरण के लिए, एक यूआई धागा)। तदनुसार, मैं नहीं चाहूंगा कि वह एक ऐसे कार्य में व्यस्त हो जो एक और धागा प्रदर्शन कर सके, इसके लिए विशेष रूप से संचालन के प्रदर्शन का त्याग।

अतुल्यकालिक एक बहुत व्यापक अवधारणा है और इसे कई तरीकों से प्राप्त किया जा सकता है।
निम्नलिखित को .NET के इतिहास में प्रतिष्ठित किया जा सकता है :

ईएपी (ईवेंट-आधारित एसिंक्रोनस पैटर्न) - जैसा कि नाम से पता चलता है, हाइक उन घटनाओं पर आधारित है जो ऑपरेशन पूरा होने पर आग लगाते हैं और इस ऑपरेशन को कॉल करने वाली सामान्य विधि
एपीएम (अतुल्यकालिक प्रोग्रामिंग मॉडल) - 2 विधियों पर आधारित। BeginSmth विधि IAsyncResult इंटरफ़ेस देता है। EndSmth विधि IAsyncResult को स्वीकार करता है (यदि ऑपरेशन समय से पूरा नहीं होता है, तो EndSmth कहा जाता है, थ्रेड अवरुद्ध है)
TAP (टास्क-आधारित एसिंक्रोनस पैटर्न) समान async / प्रतीक्षारत है (सख्ती से बोलते हुए, ये शब्द दृष्टिकोण और टास्क और टास्क <TResult> के प्रकार के बाद दिखाई दिए, लेकिन async / प्रतीक्षा में इस अवधारणा में काफी सुधार हुआ)

उत्तरार्द्ध दृष्टिकोण इतना सफल था कि हर कोई पिछले वाले के बारे में सफलतापूर्वक भूल गया। तो, यह उसके बारे में होगा।

टास्क-आधारित एसिंक्रोनस पैटर्न। सिंटेक्स और संकलन की स्थिति

मानक TAP- शैली अतुल्यकालिक विधि लिखना बहुत आसान है।

ऐसा करने के लिए, आपको चाहिए :

टास्क, टास्क <T>, या शून्य होने के लिए वापसी मूल्य के लिए (बाद में चर्चा नहीं की गई है)। C # 7 में टास्क जैसे प्रकार (अंतिम अध्याय में चर्चा की गई) आए। C # 8 में, IAsyncEnumerable <T> और IAsyncEnumerator <T> को इस सूची में जोड़ा गया है।
ताकि विधि को एस्किंक कीवर्ड के साथ चिह्नित किया जाए और अंदर प्रतीक्षा हो। ये कीवर्ड जोड़े गए हैं। इसके अलावा, यदि विधि में प्रतीक्षा है, तो इसे async चिह्नित करना सुनिश्चित करें, विपरीत सच नहीं है, लेकिन यह व्यर्थ है
शालीनता के लिए, Async प्रत्यय सम्मेलन द्वारा पालन करें। बेशक, संकलक इसे एक त्रुटि नहीं मानेंगे। यदि आप एक बहुत ही अच्छे डेवलपर हैं, तो आप एक रद्दकरण के साथ ओवरलोड जोड़ सकते हैं (पिछले अध्याय में चर्चा की गई)

इस तरह के तरीकों के लिए, कंपाइलर एक गंभीर काम करता है। और वे पर्दे के पीछे पूरी तरह से पहचाने नहीं जाते हैं, लेकिन बाद में उस पर और अधिक।

यह उल्लेख किया गया था कि विधि में प्रतीक्षित खोजशब्द होना चाहिए। यह (शब्द) कार्य के प्रदर्शन के लिए अतुल्यकालिक प्रतीक्षा की आवश्यकता को इंगित करता है, जो कि वह कार्य ऑब्जेक्ट है जिस पर इसे लागू किया जाता है।

टास्क ऑब्जेक्ट में कुछ शर्तें भी होती हैं, ताकि उस पर आवेदन किया जा सके:

अपेक्षित प्रकार में एक सार्वजनिक (या आंतरिक) GetAwaiter () विधि होनी चाहिए, यह एक विस्तार विधि भी हो सकती है। यह विधि प्रतीक्षा ऑब्जेक्ट देता है।
प्रतीक्षा ऑब्जेक्ट को INotifyCompletion इंटरफ़ेस को लागू करना चाहिए, जिसके लिए शून्य OnCompleted (क्रिया निरंतरता) विधि के कार्यान्वयन की आवश्यकता होती है। यह भी होना चाहिए उदाहरण संपत्ति बूल IsCompleted, शून्य GetResult () विधि। यह एक संरचना या एक वर्ग हो सकता है।

नीचे दिए गए उदाहरण से पता चलता है कि एक इंट की उम्मीद कैसे की जाती है, और यहां तक कि कभी भी निष्पादित नहीं किया जाता है।

एक्सटेंशन इंट

public class Program { public static async Task Main() { await 1; } } public static class WeirdExtensions { public static AnyTypeAwaiter GetAwaiter(this int number) => new AnyTypeAwaiter(); public class AnyTypeAwaiter : INotifyCompletion { public bool IsCompleted => false; public void OnCompleted(Action continuation) { } public void GetResult() { } } }

TAP के साथ काम करें

यह समझे बिना जंगल में जाना मुश्किल है कि कैसे कुछ काम करना चाहिए। कार्यक्रम के व्यवहार के संदर्भ में TAP पर विचार करें।

शब्दावली में: प्रश्न में अतुल्यकालिक विधि, जिसके कोड पर विचार किया जाएगा, मैं एसिंक्रोनस विधि को कॉल करूंगा, और इसके भीतर बुलाया अतुल्यकालिक विधियों को मैं अतुल्यकालिक ऑपरेशन कहूंगा।

आइए सबसे सरल उदाहरण लेते हैं, एक अतुल्यकालिक ऑपरेशन के रूप में हम टास्क लेते हैं। डेल, जो स्ट्रीम को अवरुद्ध किए बिना निर्दिष्ट समय के लिए देरी करता है।

 public static async Task DelayOperationAsync() //   { BeforeCall(); Task task = Task.Delay(1000); //  AfterCall(); await task; AfterAwait(); }

व्यवहार के संदर्भ में विधि का निष्पादन निम्नानुसार है।

एसिंक्रोनस ऑपरेशन के आह्वान से पहले होने वाले सभी कोड को निष्पादित किया जाता है। इस मामले में, यह प्रीकॉल विधि है
एक अतुल्यकालिक ऑपरेशन कॉल जारी है। इस स्तर पर, धागे को मुक्त या अवरुद्ध नहीं किया जाता है। यह ऑपरेशन परिणाम - उल्लिखित कार्य ऑब्जेक्ट (आमतौर पर टास्क) को लौटाता है, जिसे एक स्थानीय चर में संग्रहीत किया जाता है
कोड को एसिंक्रोनस ऑपरेशन को कॉल करने के बाद निष्पादित किया जाता है, लेकिन प्रतीक्षा (प्रतीक्षा) से पहले। उदाहरण में - AfterCall
कार्य ऑब्जेक्ट (जो एक स्थानीय चर में संग्रहीत है) पर पूरा होने की प्रतीक्षा कर रहा है - प्रतीक्षा कार्य।

यदि इस बिंदु पर एसिंक्रोनस ऑपरेशन पूरा हो गया है, तो निष्पादन समान रूप से, उसी थ्रेड में जारी रहता है।

यदि एसिंक्रोनस ऑपरेशन पूरा नहीं हुआ है, तो कोड को बचाया जाता है जिसे एसिंक्रोनस ऑपरेशन (तथाकथित निरंतरता) के पूरा होने पर बुलाया जाना चाहिए, और स्ट्रीम थ्रेड पूल में वापस आ जाता है और उपयोग के लिए उपलब्ध हो जाता है।
प्रतीक्षा के बाद संचालन का निष्पादन - AfterAwait - तुरंत या तो उसी थ्रेड में किया जाता है, जब प्रतीक्षा के समय ऑपरेशन पूरा हो गया था, या, ऑपरेशन पूरा होने पर, एक नया धागा लिया जाता है जो जारी रहेगा (पिछले चरण में सहेजा गया)

पर्दे के पीछे। स्टेट मशीन

वास्तव में, हमारी विधि संकलक द्वारा एक ठूंठ विधि में तब्दील हो जाती है जिसमें उत्पन्न वर्ग - राज्य मशीन - आरम्भिक होता है। फिर यह (मशीन) शुरू होता है, और चरण 2 में उपयोग की जाने वाली टास्क ऑब्जेक्ट विधि से वापस आ जाती है।

विशेष रूप से रुचि राज्य मशीन का मूवमेंट विधि है। यह विधि वह करता है जो अतुल्यकालिक विधि में रूपांतरण से पहले था। यह प्रत्येक प्रतीक्षा कॉल के बीच कोड को तोड़ता है। प्रत्येक भाग मशीन की एक निश्चित स्थिति में किया जाता है। MoveNext विधि प्रतीक्षा ऑब्जेक्ट के लिए एक निरंतरता के रूप में जुड़ी हुई है। राज्य का संरक्षण उसके ठीक उसी हिस्से के निष्पादन की गारंटी देता है, जो तार्किक रूप से अपेक्षा का पालन करता है।

जैसा कि वे कहते हैं, 100 बार सुनने की तुलना में 1 बार देखना बेहतर है, इसलिए मैं अत्यधिक अनुशंसा करता हूं कि आप नीचे दिए गए उदाहरण से खुद को परिचित करें। मैंने कोड को फिर से लिखा, चर नामकरण में सुधार किया और उदारतापूर्वक टिप्पणी की।

स्रोत कोड

 public static async Task Delays() { Console.WriteLine(1); await Task.Delay(1000); Console.WriteLine(2); await Task.Delay(1000); Console.WriteLine(3); await Task.Delay(1000); Console.WriteLine(4); await Task.Delay(1000); Console.WriteLine(5); await Task.Delay(1000); }

ठूंठ विधि

 [AsyncStateMachine(typeof(DelaysStateMachine))] [DebuggerStepThrough] public Task Delays() { DelaysStateMachine stateMachine = new DelaysStateMachine(); stateMachine.taskMethodBuilder = AsyncTaskMethodBuilder.Create(); stateMachine.currentState = -1; AsyncTaskMethodBuilder builder = stateMachine.taskMethodBuilder; taskMethodBuilder.Start(ref stateMachine); return stateMachine.taskMethodBuilder.Task; }

स्टेट मशीन

 [CompilerGenerated] private sealed class DelaysStateMachine : IAsyncStateMachine { //  ,     await   //       await'a public int currentState; public AsyncTaskMethodBuilder taskMethodBuilder; //   private TaskAwaiter taskAwaiter; //  ,             ""  public int paramInt; private int localInt; private void MoveNext() { int num = currentState; try { TaskAwaiter awaiter5; TaskAwaiter awaiter4; TaskAwaiter awaiter3; TaskAwaiter awaiter2; TaskAwaiter awaiter; switch (num) { default: localInt = paramInt; //  await Console.WriteLine(1); //  await awaiter5 = Task.Delay(1000).GetAwaiter(); //  await if (!awaiter5.IsCompleted) //  await. ,    { num = (currentState = 0); // ,      taskAwaiter = awaiter5; //    ,        DelaysStateMachine stateMachine = this; //    taskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter5, ref stateMachine); //                 return; } goto Il_AfterFirstAwait; //  ,   ,    case 0: //            ,        .   ,          awaiter5 = taskAwaiter; //   taskAwaiter = default(TaskAwaiter); //   num = (currentState = -1); //  goto Il_AfterFirstAwait; //       case 1: //  ,      ,    ,     . awaiter4 = taskAwaiter; taskAwaiter = default(TaskAwaiter); num = (currentState = -1); goto Il_AfterSecondAwait; case 2: // ,     . awaiter3 = taskAwaiter; taskAwaiter = default(TaskAwaiter); num = (currentState = -1); goto Il_AfterThirdAwait; case 3: //    awaiter2 = taskAwaiter; taskAwaiter = default(TaskAwaiter); num = (currentState = -1); goto Il_AfterFourthAwait; case 4: //    { awaiter = taskAwaiter; taskAwaiter = default(TaskAwaiter); num = (currentState = -1); break; } Il_AfterFourthAwait: awaiter2.GetResult(); Console.WriteLine(5); //     awaiter = Task.Delay(1000).GetAwaiter(); //   if (!awaiter.IsCompleted) { num = (currentState = 4); taskAwaiter = awaiter; DelaysStateMachine stateMachine = this; taskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine); return; } break; Il_AfterFirstAwait: //  ,        awaiter5.GetResult(); //       Console.WriteLine(2); //  ,     await awaiter4 = Task.Delay(1000).GetAwaiter(); //    if (!awaiter4.IsCompleted) { num = (currentState = 1); taskAwaiter = awaiter4; DelaysStateMachine stateMachine = this; taskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter4, ref stateMachine); return; } goto Il_AfterSecondAwait; Il_AfterThirdAwait: awaiter3.GetResult(); Console.WriteLine(4); //     awaiter2 = Task.Delay(1000).GetAwaiter(); //   if (!awaiter2.IsCompleted) { num = (currentState = 3); taskAwaiter = awaiter2; DelaysStateMachine stateMachine = this; taskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine); return; } goto Il_AfterFourthAwait; Il_AfterSecondAwait: awaiter4.GetResult(); Console.WriteLine(3); //     awaiter3 = Task.Delay(1000).GetAwaiter(); //   if (!awaiter3.IsCompleted) { num = (currentState = 2); taskAwaiter = awaiter3; DelaysStateMachine stateMachine = this; taskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter3, ref stateMachine); return; } goto Il_AfterThirdAwait; } awaiter.GetResult(); } catch (Exception exception) { currentState = -2; taskMethodBuilder.SetException(exception); return; } currentState = -2; taskMethodBuilder.SetResult(); //    ,   ,       } void IAsyncStateMachine.MoveNext() {...} [DebuggerHidden] private void SetStateMachine(IAsyncStateMachine stateMachine) {...} void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine) {...} }

मैं वाक्यांश पर ध्यान केंद्रित करता हूं "इस बिंदु पर सिंक्रनाइज़ रूप से निष्पादित नहीं किया गया है।" एक एसिंक्रोनस ऑपरेशन भी एक तुल्यकालिक निष्पादन पथ का अनुसरण कर सकता है। वर्तमान अतुल्यकालिक विधि के लिए मुख्य रूप से निष्पादित की जाने वाली समकालिक विधि, यानि कि थ्रेड को बदले बिना, IsCompleted सत्यापन के समय एसिंक्रोनस ऑपरेशन का पूरा होना।

यह उदाहरण स्पष्ट रूप से इस व्यवहार को प्रदर्शित करता है।

 static async Task Main() { Console.WriteLine(Thread.CurrentThread.ManagedThreadId); //1 Task task = Task.Delay(1000); Thread.Sleep(1700); await task; Console.WriteLine(Thread.CurrentThread.ManagedThreadId); //1 }

सिंक्रनाइज़ेशन संदर्भ के बारे में। मशीन में प्रयुक्त AwaitUnsafeOnCompleted विधि अंततः कॉल का परिणाम देती है। Task.SetContinuationForAwait विधि। इस विधि में, वर्तमान सिंक्रनाइज़ेशन संदर्भ सिंक्रोनाइज़ेशनकोटेक्स्ट.क्रिकेट प्राप्त होता है। सिंक्रनाइज़ेशन संदर्भ को एक प्रकार की धारा के रूप में व्याख्या की जा सकती है। यदि यह विशिष्ट भी है (उदाहरण के लिए, यूआई थ्रेड का संदर्भ), तो एक सिंक्रनाइज़ेशन SynchronizationContextAwaitTaskContinuation class का उपयोग करके बनाया जाता है। निरंतरता शुरू करने के लिए यह वर्ग सहेजे गए संदर्भ पर पोस्ट विधि को कॉल करता है, जो यह सुनिश्चित करता है कि निरंतरता को सटीक संदर्भ में निष्पादित किया जाता है जहां विधि को चलाया गया था। निरंतरता को निष्पादित करने के लिए विशिष्ट तर्क एक संदर्भ में पोस्ट विधि पर निर्भर करता है, जो इसे हल्के ढंग से रखने के लिए, गति के लिए नहीं जाना जाता है। यदि कोई सिंक्रनाइज़ेशन संदर्भ नहीं था (या यह इंगित किया गया था कि यह हमारे लिए कोई मायने नहीं रखता है कि कन्फिगरएविट (गलत), जिसे अंतिम अध्याय में चर्चा की जाएगी) का उपयोग जारी रहेगा, पूल से थ्रेड द्वारा जारी रखा जाएगा।

अतुल्यकालिक की उत्पत्ति। डिवाइस मानक अतुल्यकालिक तरीके

हमने देखा कि कैसे async और वेट का उपयोग करने वाला एक तरीका दिखता है और पर्दे के पीछे क्या होता है। यह जानकारी असामान्य नहीं है। लेकिन अतुल्यकालिक संचालन की प्रकृति को समझना महत्वपूर्ण है। क्योंकि, जैसा कि हमने राज्य मशीन में देखा था, अतुल्यकालिक संचालन को कोड में कहा जाता है, जब तक कि उनका परिणाम अधिक चालाक तरीके से संसाधित नहीं होता है। हालांकि, खुद अतुल्यकालिक संचालन के अंदर क्या होता है? शायद एक ही है, लेकिन यह विज्ञापन नहीं हो सकता है।

एक महत्वपूर्ण कार्य अतुल्यकालिक की प्रकृति को समझना है। जब अतुल्यकालिक समझने की कोशिश की जा रही है, तो राज्यों का एक विकल्प है "अब स्पष्ट" और "अब फिर से समझ से बाहर।" और यह विकल्प तब तक होगा जब तक कि अतुल्यकालिक के स्रोत को नहीं समझा जाता है।

अतुल्यकालिक के साथ काम करते समय, हम कार्यों पर काम करते हैं। यह एक धारा के समान बिल्कुल नहीं है। एक कार्य कई थ्रेड द्वारा किया जा सकता है, और एक थ्रेड कई कार्य कर सकता है।

एसिंक्रोनसी आमतौर पर एक विधि से शुरू होती है जो टास्क को वापस करती है (उदाहरण के लिए), लेकिन इसे एसिंक्स के साथ टैग नहीं किया गया है, और तदनुसार अंदर प्रतीक्षा का उपयोग नहीं करता है। यह विधि किसी भी कंपाइलर परिवर्तन को बर्दाश्त नहीं करती है, इसे उसी तरह निष्पादित किया जाता है।

तो, चलो अतुल्यकालिक की कुछ जड़ों को देखें।

Task.Run, नया टास्क (..)। प्रारंभ (), Factory.StartNew और पसंद करें। अतुल्यकालिक निष्पादन शुरू करने का सबसे आसान तरीका। ये विधियां बस एक नया कार्य ऑब्जेक्ट बनाती हैं, एक प्रतिनिधि को मापदंडों में से एक के रूप में पारित करती हैं। कार्य शेड्यूलर को स्थानांतरित कर दिया जाता है, जो इसे पूल में एक थ्रेड द्वारा निष्पादित किया जाता है। समाप्त कार्य जो उम्मीद की जा सकती है वह वापस आ गया है। आमतौर पर, इस दृष्टिकोण का उपयोग कंप्यूटिंग (सीपीयू-बाउंड) को एक अलग धागे में शुरू करने के लिए किया जाता है।
TaskCompletionSource। एक सहायक वर्ग जो कार्य ऑब्जेक्ट को नियंत्रित करने में मदद करता है। उन लोगों के लिए डिज़ाइन किया गया है जो कार्यान्वयन के लिए एक प्रतिनिधि को आवंटित नहीं कर सकते हैं और पूर्णता को नियंत्रित करने के लिए अधिक परिष्कृत तंत्र का उपयोग करते हैं। इसका एक बहुत ही सरल API है - SetResult, SetError, आदि, जो तदनुसार कार्य को अपडेट करते हैं। यह कार्य टास्क संपत्ति के माध्यम से उपलब्ध है। शायद अंदर आप धागे पैदा करेंगे, उनकी बातचीत के लिए जटिल तर्क है या घटना से पूरा करेंगे। इस वर्ग के बारे में थोड़ा और विवरण अंतिम अनुभाग में होगा।

एक अतिरिक्त पैराग्राफ में, आप मानक पुस्तकालयों के तरीके बना सकते हैं। इनमें पठन / लेखन फाइलें, एक नेटवर्क के साथ काम करना, और पसंद है। एक नियम के रूप में, ऐसे लोकप्रिय और सामान्य तरीके सिस्टम कॉल का उपयोग करते हैं जो विभिन्न प्लेटफार्मों पर भिन्न होते हैं, और उनका डिवाइस बेहद मनोरंजक होता है। फ़ाइलों और नेटवर्क के साथ काम करने पर विचार करें।

फ़ाइलें

एक महत्वपूर्ण नोट - यदि आप फाइलों के साथ काम करना चाहते हैं, तो फाइलस्ट्रीम बनाते समय आपको उपयोग करने योग्य = सही बताना होगा।

सब कुछ गैर-तुच्छ और भ्रामक रूप से फाइलों में व्यवस्थित है। FileStream वर्ग को आंशिक घोषित किया गया है। और इसके अलावा 6 और प्लेटफ़ॉर्म-विशिष्ट ऐड-ऑन हैं। इसलिए, यूनिक्स में, एक नियम के रूप में, एक मनमाना फ़ाइल के लिए अतुल्यकालिक एक्सेस, एक अलग थ्रेड में सिंक्रोनस ऑपरेशन का उपयोग करता है। विंडोज में अतुल्यकालिक ऑपरेशन के लिए सिस्टम कॉल हैं, जो निश्चित रूप से उपयोग किए जाते हैं। इससे विभिन्न प्लेटफार्मों पर काम में अंतर होता है। स स स ।

यूनिक्स

लिखने या पढ़ने के दौरान मानक व्यवहार समकालिक रूप से ऑपरेशन करना है, यदि बफर अनुमति देता है और स्ट्रीम किसी अन्य ऑपरेशन में व्यस्त नहीं है:

1. स्ट्रीम किसी अन्य ऑपरेशन के साथ व्यस्त नहीं है

फिलास्ट्रीम क्लास के पास सेमीफ़ॉर्फ़सिमल (1, 1) के साथ विरासत में मिली एक वस्तु है - यानी, एक ला क्रिटिकल सेक्शन - इस सेमाफ़ोर द्वारा संरक्षित कोड खंड को एक समय में केवल एक थ्रेड द्वारा निष्पादित किया जा सकता है। इस सेमाफोर का उपयोग पढ़ने और लिखने दोनों के लिए किया जाता है। यही है, एक साथ पढ़ने और लिखने दोनों का उत्पादन करना असंभव है। इस स्थिति में, अर्धवृत्त पर अवरोध उत्पन्न नहीं होता है। यह ._asyncState.WaitAsync () विधि उस पर कॉल की जाती है, जो कार्य ऑब्जेक्ट देता है (कोई लॉक या प्रतीक्षा नहीं है, यह होगा कि विधि के परिणाम के लिए प्रतीक्षित कीवर्ड लागू किया गया था)। यदि यह कार्य ऑब्जेक्ट पूरा नहीं हुआ है - अर्थात, अर्ध-भाग पर कब्जा कर लिया गया है, तो निरंतरता (टास्क.कंटीन्यूविथ) जिसमें ऑपरेशन किया जाता है, लौटे प्रतीक्षा ऑब्जेक्ट से जुड़ा हुआ है। यदि ऑब्जेक्ट स्वतंत्र है, तो आपको निम्नलिखित की जांच करने की आवश्यकता है

2. बफर अनुमति देता है

यहां व्यवहार पहले से ही ऑपरेशन की प्रकृति पर निर्भर करता है।

रिकॉर्डिंग के लिए - यह जाँच की जाती है कि फ़ाइल में लिखने + की स्थिति के लिए डेटा का आकार बफर के आकार से कम है, जो कि डिफ़ॉल्ट रूप से 4096 बाइट्स है। यही है, हमें शुरुआत से 4096 बाइट्स लिखना चाहिए, 2048 बाइट्स 2048 की ऑफसेट के साथ, और इसी तरह। यदि यह मामला है, तो ऑपरेशन को समकालिक रूप से किया जाता है, अन्यथा निरंतरता जुड़ी हुई है (टास्क। कॉन्टेक्टव्यूथ)। सीक्वल एक नियमित सिंक्रोनस सिस्टम कॉल का उपयोग करता है। जब बफ़र भर जाता है, तो इसे सिंक्रोनाइज़ करने के लिए लिखा जाता है।
पढ़ने के लिए - यह जांचा जाता है कि क्या सभी आवश्यक डेटा वापस करने के लिए बफर में पर्याप्त डेटा है या नहीं। यदि नहीं, तो, फिर से, एक तुल्यकालिक प्रणाली कॉल के साथ एक निरंतरता (टास्क.कंटीन्यूविथ)।

वैसे, एक दिलचस्प विवरण है। यदि डेटा का एक टुकड़ा पूरे बफर पर कब्जा कर लेता है, तो उन्हें बफर की भागीदारी के बिना, सीधे फ़ाइल में लिखा जाएगा। इसी समय, एक ऐसी स्थिति है जहां बफर के आकार से अधिक डेटा होगा, लेकिन वे सभी इसके माध्यम से गुजरेंगे। यदि बफर में पहले से ही कुछ है तो ऐसा होता है। फिर हमारे डेटा को 2 भागों में विभाजित किया जाएगा, एक बफर को अंत तक भरेगा और डेटा को फ़ाइल में लिखा जाएगा, दूसरे को बफर में लिखा जाएगा यदि यह इसमें हो जाता है या सीधे फ़ाइल में नहीं होता है। इसलिए, यदि हम एक स्ट्रीम बनाते हैं और उसमें 4097 बाइट्स लिखते हैं, तो वे तुरंत फाइल में दिखाई देंगे, बिना कॉल किए। यदि हम 4095 लिखते हैं, तो फ़ाइल में कुछ भी नहीं होगा।

विंडोज

विंडोज के तहत, बफर का उपयोग करने और सीधे लिखने के लिए एल्गोरिथ्म बहुत समान है। लेकिन एक महत्वपूर्ण अंतर सीधे एसिंक्रोनस सिस्टम में कॉल लिखने और पढ़ने में मनाया जाता है। सिस्टम कॉल में गहराई से जाने के बिना बोलना, ऐसी ओवरलैप्ड संरचना है। यह हमारे लिए एक महत्वपूर्ण क्षेत्र है - HANDLE hEvent। यह एक मैनुअल रीसेट घटना है जो एक ऑपरेशन के पूरा होने पर अलार्म स्थिति में जाती है। वापस लागू करने के लिए। सीधे लिखना, साथ ही साथ बफर को लिखना, अतुल्यकालिक सिस्टम कॉल का उपयोग करते हैं, जो एक पैरामीटर के रूप में उपरोक्त संरचना का उपयोग करते हैं। रिकॉर्डिंग करते समय, एक FileStreamCompletionSource ऑब्जेक्ट बनाया जाता है - TaskCompletionSource का एक इनहेरीटर, जिसमें IOCallback निर्दिष्ट है। ऑपरेशन पूरा होने पर इसे पूल से मुक्त थ्रेड कहा जाता है। कॉलबैक में, ओवरलैप्ड संरचना पार्स की जाती है और टास्क ऑब्जेक्ट उसी के अनुसार अपडेट किया जाता है। यह सब जादू है।

नेटवर्क

स्रोत को समझने में मैंने जो कुछ देखा, उसका वर्णन करना मुश्किल है। मेरा पथ HttpClient से सॉकेट तक और यूनिक्स के लिए सॉकेटएस्क्यूऑनटेक्स्ट से लेट गया। सामान्य योजना फाइलों की तरह ही है। विंडोज के लिए, उल्लिखित ओवरलैप्ड संरचना का उपयोग किया जाता है और ऑपरेशन अतुल्यकालिक रूप से किया जाता है। यूनिक्स पर, नेटवर्क ऑपरेशन भी कॉलबैक फ़ंक्शन का उपयोग करते हैं।

और थोड़ा स्पष्टीकरण। एक चौकस पाठक यह नोटिस करेगा कि कॉल और कॉलबैक के बीच अतुल्यकालिक कॉल का उपयोग करते समय, एक निश्चित खालीपन है जो किसी तरह डेटा के साथ काम करता है। यहां पूर्णता के लिए स्पष्ट करना सार्थक है। फ़ाइलों के उदाहरण पर, डिस्क नियंत्रक डिस्क नियंत्रक द्वारा डिस्क के साथ प्रत्यक्ष संचालन करता है, यह वह है जो सिर को वांछित क्षेत्र में ले जाने के बारे में संकेत देता है, आदि। प्रोसेसर इस समय मुक्त है। डिस्क के साथ संचार इनपुट / आउटपुट पोर्ट के माध्यम से होता है। वे ऑपरेशन के प्रकार, डिस्क पर डेटा का स्थान आदि इंगित करते हैं। अगला, नियंत्रक और डिस्क इस ऑपरेशन में लगे हुए हैं और काम पूरा होने पर वे एक बाधा उत्पन्न करते हैं। तदनुसार, एक अतुल्यकालिक प्रणाली कॉल केवल इनपुट / आउटपुट पोर्ट की जानकारी में योगदान देता है, जबकि सिंक्रोनस भी परिणामों के लिए इंतजार करता है, एक अवरुद्ध राज्य में धारा डाल रहा है। यह योजना बिल्कुल सटीक नहीं है (इस लेख के बारे में नहीं), लेकिन काम की एक वैचारिक समझ देता है।

अब प्रक्रिया की प्रकृति स्पष्ट है। लेकिन कोई पूछ सकता है कि अतुल्यकालिक के साथ क्या करना है? यह हमेशा के लिए एक विधि पर async लिखना असंभव है।

सबसे पहले। एक सेवा के रूप में एक आवेदन किया जा सकता है। इस मामले में, प्रवेश बिंदु - मुख्य - आपके द्वारा खरोंच से लिखा गया है। कुछ समय पहले तक, मेन अतुल्यकालिक नहीं हो सकता था, भाषा के संस्करण 7 में, यह सुविधा जोड़ी गई थी। लेकिन यह मौलिक रूप से कुछ भी नहीं बदलता है, बस कंपाइलर सामान्य मेन उत्पन्न करता है, और एसिंक्रोनस से बस एक स्टैटिक विधि बनाई जाती है, जिसे मेन में कहा जाता है और इसके पूरा होने की उम्मीद है। तो, सबसे अधिक संभावना है कि आपके पास कुछ लंबे समय तक रहने वाली क्रियाएं हैं। किसी कारण से, इस समय, बहुत से लोग इस व्यवसाय के लिए थ्रेड बनाने के बारे में सोचना शुरू करते हैं: सामान्य रूप से टास्क, थ्रेडपूल या थ्रेड के माध्यम से, क्योंकि किसी चीज़ में अंतर होना चाहिए। जवाब आसान है - बेशक टास्क। यदि आप TAP दृष्टिकोण का उपयोग करते हैं, तो मैन्युअल थ्रेड निर्माण में हस्तक्षेप न करें। यह लगभग सभी अनुरोधों के लिए HttpClient का उपयोग करने के लिए समान है, और सॉकेट के माध्यम से POST स्वतंत्र रूप से किया जाता है।

दूसरा। वेब अनुप्रयोग। प्रत्येक आने वाले अनुरोध में प्रसंस्करण के लिए थ्रेडपूल से एक नया थ्रेड खींचने का कारण बनता है। बेशक, पूल बड़ा है, लेकिन अनंत नहीं है। मामले में जब बहुत सारे अनुरोध होते हैं, तो पर्याप्त थ्रेड्स नहीं हो सकते हैं, और प्रसंस्करण के लिए सभी नए अनुरोध कतारबद्ध होंगे। इस स्थिति को भुखमरी कहा जाता है। लेकिन अतुल्यकालिक नियंत्रकों का उपयोग करने के मामले में, जैसा कि पहले चर्चा की गई थी, धारा पूल में लौटती है और नए अनुरोधों को संसाधित करने के लिए उपयोग किया जा सकता है। इस प्रकार, सर्वर का थ्रूपुट काफी बढ़ जाता है।

हमने शुरुआत से लेकर अंत तक अतुल्यकालिक प्रक्रिया को देखा। , , .

TAP

Task.

Task . .

Task.WhenAny(..) — , IEnumerable/params , .
Task.WhenAll(..) — , IEnumerable/params ,
Task.FromResult<T>(T value) — , .
Task.Delay(..) —
Task.Yield() — . , . , ,

ConfigureAwait

, «» . Task , , . , , Post. , , Post — . , 1- , , , , UI, .ConfigureAwait(false) . , , .

. , .

- -, . , . - ASP.NET Core - ( , ). , Post .

TaskCompletionSource<T>

, Task. , , , . , TAP, , . :

उदाहरण

 public static Task<string> GetSomeDataAsync() { TaskCompletionSource<string> tcs = new TaskCompletionSource<string>(); FileSystemWatcher watcher = new FileSystemWatcher { Path = Directory.GetCurrentDirectory(), NotifyFilter = NotifyFilters.LastAccess, EnableRaisingEvents = true }; watcher.Changed += (o, e) => tcs.SetResult(e.FullPath); return tcs.Task; }

, .

CancellationTokenSource

. TaskCompletionSource. var cts = new CancellationTokenSource() , , , IDisposable, cts.Token . , - , cts.Cancel() . .

CancellationToken . , , while, : cancellationToken.ThrowIfCancellationRequested() , OperationCanceledException । यह अपवाद ऑपरेशन रद्द करने के रूप में माना जाता है और कार्य ऑब्जेक्ट के अंदर अपवाद के रूप में सहेजा नहीं जाता है। साथ ही, टास्क ऑब्जेक्ट पर लगाई गई संपत्ति सत्य हो जाएगी।

LongRunning

, , , . , . ( ), . :

Task.Factory.StartNew(action, TaskCreationOptions.LongRunning )

Task.Factory.StartNew , .

अतुल्यकालिक कोड निष्पादन की गैर-नियतात्मक प्रकृति के कारण, अपवादों का प्रश्न बहुत प्रासंगिक है। यह एक शर्म की बात होगी यदि आप अपवाद को नहीं पकड़ सकते हैं और इसे बाएं धागे में फेंक दिया गया है, इस प्रक्रिया को मार रहा है। ExceptionDispatchInfo वर्ग को एक थ्रेड में एक अपवाद को पकड़ने और उसमें फेंकने के लिए बनाया गया था । अपवाद को पकड़ने के लिए, स्थिर विधि ExceptionDispatchInfo.Capture (पूर्व) का उपयोग किया जाता है, जो ExceptionDispatchInfo लौटाता है । , Throw() . , await. , await void . , Post. . 100% . , Task Task<T>, void.

. TaskScheduler.UnobservedTaskException , , UnobservedTaskException . , GC , .

IAsyncEnumerable

C# 8 .NET Core 3.0 - (yield) , Task<IEnumerable<T>>, .. . . . IAsyncEnumerable<T> ( IAsyncEnumerator<T> ). foreach await. WithCancellation ConfigureAwait , CancelationToken .

, , .
, .

उदाहरण

 public class Program { public static async Task Main() { Stopwatch sw = new Stopwatch(); sw.Start(); IAsyncEnumerable<int> enumerable = AsyncYielding(); Console.WriteLine($"Time after calling: {sw.ElapsedMilliseconds}"); await foreach (var element in enumerable.WithCancellation(..).ConfigureAwait(false)) { Console.WriteLine($"element: {element}"); Console.WriteLine($"Time: {sw.ElapsedMilliseconds}"); } } static async IAsyncEnumerable<int> AsyncYielding() { foreach (var uselessElement in Enumerable.Range(1, 3)) { Task task = Task.Delay(TimeSpan.FromSeconds(uselessElement)); Console.WriteLine($"Task run: {uselessElement}"); await task; yield return uselessElement; } } }

:

Time after calling: 0
Task run: 1
element: 1
Time: 1033
Task run: 2
element: 2
Time: 3034
Task run: 3
element: 3
Time: 6035

ThreadPool

TAP. . ThreadPool : + . , . , , , — . , . , . — . , , , . , . , , .

— background- ( isBackground = true). , foreground- .

wait handle. , ( Windows).

Task-like

, ( ) . [AsyncMethodBuilder(..)] . await. — , .

— , . SetResult T task-like , T. .

 class MyTaskMethodBuilder<T> { public static MyTaskMethodBuilder<T> Create(); public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine; public void SetStateMachine(IAsyncStateMachine stateMachine); public void SetException(Exception exception); public void SetResult(T result); public void AwaitOnCompleted<TAwaiter, TStateMachine>( ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine; public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>( ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine; public MyTask<T> Task { get; } }

Task-like . , .

. , , , . — , SetStateMachine , . stateMachine.MoveNext Start , . Start , Task. .

, SetResult , SetException . await, GetAwaiter() task-like . ICriticalNotifyCompletion IsCompleted = false, builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine) . AwaitUnsafeOnCompleted awaiter.OnCompleted(action) , action stateMachine.MoveNext . INotifyCompletion builder.AwaitOnCompleted .

— . 514 , . . - , , . , Main() ( - Microsoft). , -, .

 public class Program { public static void Main() { Console.WriteLine("Start"); JustMethod().Task.Wait(); //   Console.WriteLine("Stop"); } public static async LogTask JustMethod() { await DelayWrapper(1000); } public static LogTask DelayWrapper(int milliseconds) => new LogTask { Task = Task.Delay(milliseconds)}; } [AsyncMethodBuilder(typeof(LogMethodBuilder))] public class LogTask { public Task Task { get; set; } public TaskAwaiter GetAwaiter() => Task.GetAwaiter(); } public class LogMethodBuilder { private AsyncTaskMethodBuilder _methodBuilder = AsyncTaskMethodBuilder.Create(); private LogTask _task; public static LogMethodBuilder Create() { Console.WriteLine($"Method: Create; {DateTime.Now :O}"); return new LogMethodBuilder(); } public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { Console.WriteLine($"Method: Start; {DateTime.Now :O}"); _methodBuilder.Start(ref stateMachine); } public void SetStateMachine(IAsyncStateMachine stateMachine) { Console.WriteLine($"Method: SetStateMachine; {DateTime.Now :O}"); _methodBuilder.SetStateMachine(stateMachine); } public void SetException(Exception exception) { Console.WriteLine($"Method: SetException; {DateTime.Now :O}"); _methodBuilder.SetException(exception); } public void SetResult() { Console.WriteLine($"Method: SetResult; {DateTime.Now :O}"); _methodBuilder.SetResult(); } public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { Console.WriteLine($"Method: AwaitOnCompleted; {DateTime.Now :O}"); _methodBuilder.AwaitOnCompleted(ref awaiter, ref stateMachine); } public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { Console.WriteLine($"Method: AwaitUnsafeOnCompleted; {DateTime.Now :O}"); _methodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine); } public LogTask Task { get { Console.WriteLine($"Property: Task; {DateTime.Now :O}"); return _task ??= new LogTask {Task = _methodBuilder.Task}; } set => _task = value; } }

निष्कर्ष:

प्रारंभ
विधि: बनाएँ; 2019-10-09T17: 55: 13.7152733 + 03: 00
विधि: प्रारंभ; 2019-10-09T17: 55: 13.7262226 + 03: 00
विधि: AwaitUnsafeOnCompleted; 2019-10-09T17: 55: 13.7275206 + 03: 00
संपत्ति: कार्य; 2019-10-09T17: 55: 13.7292005 + 03: 00
विधि: SetResult; 2019-10-09T17: 55: 14.7297967 + 03: 00
बंद करो

, आप सभी को धन्यवाद।

C # में Async / प्रतीक्षा करें: अवधारणा, आंतरिक डिज़ाइन, उपयोगी ट्रिक्स