🚉 ⚙️ 🧙🏻 अमीर इंटरनेट अनुप्रयोग और सज्जाकार में अतुल्यकालिक टाइपस्क्रिप्ट यह मुकाबला करने के लिए ⏲️ ☂️ 🗓️

async / await के आगमन के बाद से, टाइपस्क्रिप्ट ने कई लेख प्रकाशित किए हैं जो इस विकास दृष्टिकोण ( हैकर्नून , blog.bitsrc.io , habr.com ) को बाहर निकालते हैं । हम उन्हें क्लाइंट की तरफ से शुरू करते हैं (जब ES6 जेनरेटर 50% से कम ब्राउज़रों का समर्थन करते हैं)। और अब मैं अपने अनुभव को साझा करना चाहता हूं, क्योंकि समानांतर निष्पादन वह सब नहीं है जो इस मार्ग के साथ जानना अच्छा होगा।

मुझे वास्तव में अंतिम लेख पसंद नहीं है: कुछ समझ से बाहर हो सकता है। आंशिक रूप से इस तथ्य के कारण कि मैं मालिकाना कोड प्रदान नहीं कर सकता हूं - केवल सामान्य दृष्टिकोण को रेखांकित करने के लिए। इसलिए:

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

मुख्य प्रौद्योगिकियों की सूची:

परियोजना को मुख्य रूप से कई जावास्क्रिप्ट पुस्तकालयों का उपयोग करके टाइपस्क्रिप्ट में लिखा गया है। मुख्य पुस्तकालय ExtJS है। यह रिएक्ट करने के लिए फैशन में हीनता है, लेकिन यह एक समृद्ध इंटरफेस के साथ एक उद्यम उत्पाद के लिए सबसे उपयुक्त है: कई तैयार घटकों, बॉक्स से बाहर अच्छी तरह से डिज़ाइन किए गए टेबल, विकास को सरल बनाने के लिए संबंधित उत्पादों का एक समृद्ध पारिस्थितिकी तंत्र।
अतुल्यकालिक मल्टीथ्रेडेड सर्वर।
Websocket के माध्यम से RPC का उपयोग क्लाइंट और सर्वर के बीच परिवहन के रूप में किया जाता है। कार्यान्वयन .NET WCF के समान है।
- कोई भी वस्तु एक सेवा है।
- किसी भी वस्तु को मूल्य और संदर्भ दोनों द्वारा प्रेषित किया जा सकता है।
डेटा अनुरोध इंटरफ़ेस केवल टाइपस्क्रिप्ट पर, फेसबुक से ग्राफ़िकल जैसा दिखता है।
दो-तरफ़ा संचार: डेटा अद्यतन का आरंभ क्लाइंट और सर्वर से दोनों से किया जा सकता है।
एसिंक्रोनस कोड को टाइपक्रिसिप्ट के एसिंक्स / वेट फ़ंक्शन के उपयोग के माध्यम से क्रमिक रूप से लिखा जाता है।
सर्वर एपीआई टाइपस्क्रिप्ट में उत्पन्न होता है: यदि यह बदलता है, तो त्रुटि के मामले में बिल्ड तुरंत दिखाएगा।

आउटपुट क्या है

मैं आपको बताता हूं कि हम इस के साथ कैसे काम करते हैं और हमने अतुल्यकालिक कोड के सुरक्षित, गैर-प्रतिस्पर्धी निष्पादन के लिए क्या किया है: हमारे टाइपसट्रिप सज्जाकार जो कतारों की कार्यक्षमता को लागू करते हैं। मूल से लेकर दौड़ की स्थिति और विकास प्रक्रिया के दौरान उत्पन्न होने वाली अन्य कठिनाइयों का समाधान।

सर्वर से प्राप्त डेटा कैसे संरचित है

सर्वर एक मूल वस्तु देता है जिसमें एक ग्राफ के रूप में इसके गुणों में डेटा (अन्य ऑब्जेक्ट, ऑब्जेक्ट्स, पंक्तियों आदि का संग्रह) होता है। यह कारण है, आवेदन करने के लिए अन्य बातों के साथ:

यह डेटा विश्लेषण / हैंडलर नोड्स के एक निर्देशित ग्राफ को एमएल बनाता है।
बदले में प्रत्येक नोड का अपना एम्बेडेड ग्राफ हो सकता है
रेखांकन में निर्भरताएँ होती हैं: नोड्स "वंशानुगत" हो सकते हैं, और नए नोड्स उनके "वर्ग" द्वारा बनाए जाते हैं।

लेकिन ग्राफ़ के रूप में क्वेरी संरचना को लगभग किसी भी एप्लिकेशन में लागू किया जा सकता है, और ग्राफक्यूएल, जहां तक मुझे पता है, इसके विनिर्देश में भी इसका उल्लेख है।

उदाहरण डेटा संरचना:

 //   interface IParent { ServerId: string; Nodes: INodes; // INodes -     INode } //     interface INodes<TNode extends INode> extends ICollection { IndexOf(item: TNode): number; Item(index: number): TNode; // ...     } //    interface INode extends IItem { Guid: string; Name: string; DisplayName: string; Links: ILinks; // ILinks -    Info: INodeInfo; //    -  } //      interface ILink { Guid: string; DisplayName: string; SourceNode: INode; //   -  TargetNode: INode; //   ,   } interface INodeInfo { Component: IComponent; ConfigData: IData; }

क्लाइंट को डेटा कैसे प्राप्त होता है

यह सरल है: जब आप एक गैर-स्केलर प्रकार की वस्तु की संपत्ति का अनुरोध करते हैं, तो आरपीसी रिटर्न Promise :

 let Nodes = Parent.Nodes; // Nodes -> Promise<INodes>

एक "कॉलबैक हेल" के बिना अतुल्यकालिक।

"अनुक्रमिक" अतुल्यकालिक कोड को व्यवस्थित करने के लिए, टाइपस्क्रिप्ट async / await कार्यक्षमता का उपयोग किया जाता है:

 async function ShowNodes(parent: IParent): Promise<void> { //    let Nodes = await parent.Nodes; //       await Nodes.forEachParallel(async function(node): Promise<void> { await RenderNode(node); //          }); }

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

संक्षेप में, उन लोगों के लिए सार जो विषय से परिचित नहीं हैं:

जैसे ही आप async कीवर्ड को फंक्शन में जोड़ते हैं, यह स्वचालित रूप से Promise<_> लौटा देगा। ऐसे कार्यों की विशेषताएं:

async फ़ंक्शन के अंदर अभिव्यक्तियाँ await साथ (जो Promise वापस करती हैं) फ़ंक्शन के निष्पादन को रोक देंगी और अपेक्षित Promise हल करने के बाद जारी रखेंगी।
यदि कोई अपवाद async फ़ंक्शन में होता है, तो दिए गए Promise को इस अपवाद के साथ अस्वीकार कर दिया जाएगा।
जब जावास्क्रिप्ट कोड में संकलित किया जाता है, तो ES6 मानक ( function* एस्किंक function* बजाय async function और await बजाय yield ) के लिए जनरेटर होंगे या ES5 (राज्य मशीन) के लिए switch के साथ डरावना कोड। await एक कीवर्ड है जो एक वादा के परिणाम की प्रतीक्षा करता है। बैठक के समय, कोड के निष्पादन के दौरान, ShowNodes फ़ंक्शन बंद हो जाता है, और डेटा की प्रतीक्षा करते समय, जावास्क्रिप्ट कुछ अन्य कोड निष्पादित कर सकता है।

उपरोक्त कोड में, संग्रह में एक forEachParallel विधि है जो समानांतर में प्रत्येक नोड के लिए एक अतुल्यकालिक कॉलबैक कहती है। उसी समय, Nodes.forEachParallel से पहले प्रतीक्षा करें सभी कॉलबैक के लिए प्रतीक्षा करेंगे। कार्यान्वयन के अंदर - Promise.all :

 /** *            * @param items  * @param callbackfn  * @param [thisArg]   ,      this  callbackfn */ export async function forEachParallel<T>(items: IItemArray<T>, callbackfn: (value: T, index: int, items: IItemArray<T>) => Promise<void | any>, thisArg?: any): Promise<void> { let xCount = items ? await items.Count : 0; if (!xCount) return; let xActions = new Array<Promise<void | any>>(xCount); for (let i = 0; i < xCount; i++) { let xItem = items.Item(i); xActions[i] = ExecuteCallback(xItem, callbackfn, i, items, thisArg); } await Promise.all(xActions); } /**   item   callbackfn */ async function ExecuteCallback<T>(item: Promise<T> | T, callbackfn: (value: T, index: int, items: IItemArray<T>) => Promise<void | any>, index: int, items: IItemArray<T>, thisArg?: any): Promise<void> { let xItem = await item; await callbackfn.call(thisArg, xItem, index, items); }

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

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

क्वेरी भाषा

कई कार्य हैं जो सर्वर से डेटा के लिए अनुरोध बनाने के लिए उपयोग किए जाते हैं। वे "बता" सर्वर जो प्रतिक्रिया में लौटने के लिए डेटा ग्राफ के नोड्स:

 /** *       item    Promise  , *      properties */ selectAsync<T extends IItem>(item: T, properties: () => any[]): Promise<T>; /** *   items,       properties */ selectAsyncAll<T extends ICollection>(items: T[], properties: () => any[]): Promise<T[]>; /**    selectAsync     */ select<T>(item: T, properties: () => any[]): T; /**    selectAsync     */ selectAll<T>(items: T[], properties: () => any[]): T[];

अब सर्वर पर एक कॉल के साथ आवश्यक एम्बेडेड डेटा का अनुरोध करने के लिए इन कार्यों के आवेदन को देखें:

 async function ShowNodes(parentPoint: IParent): Promise<void> { //       IParent -    selectAsync ( // Promise,  ). let Parent = await selectAsync(parentPoint, parent => [ //           selectAll(parent.Nodes, nodes => [node.Name, node.DisplayName]) // [node.Name, node.DisplayName] -        ]); //      Parent.Nodes ... }

गहराई से एम्बेडेड जानकारी के साथ थोड़ी अधिक जटिल क्वेरी का एक उदाहरण:

 //     parent.Nodes  selectAsyncAll,    let Parent = await selectAsyncAll(parent.Nodes, nodes => [ //    : select(node, node => [ node.Name, node.DisplayName, selectAll(node.Links, link => [ link.Guid, link.DisplayName, select(link.TargetNode, targetNode => [targetNode.Guid]) ]), select(node.Info, info => [info.Component]) //    IInfo    IComponent,   ,   ,        ]) ]);

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

रेस की स्थिति और समाधान

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

ऐसी सरलीकृत स्थिति की कल्पना करें: IParent ऑब्जेक्ट में एक IParent सर्वर प्रतिनिधि है।

 /**   */ Parent.OnSynchronize.AddListener(async function(): Promise<void> { //  .   ,  . });

यह तब कहा जाता है जब सर्वर पर INodes नोड्स की सूची अपडेट की जाती है। फिर, निम्नलिखित परिदृश्य में, एक दौड़ की स्थिति संभव है:

हम क्लाइंट से नोड के अतुल्यकालिक हटाने का कारण बनते हैं, जो क्लाइंट ऑब्जेक्ट को हटाने के लिए पूरा होने की प्रतीक्षा कर रहा है
```
 async function OnClickRemoveNode(node: INode): Promise<void> { let removedOnServer: boolean = await Parent.RemoveNode(node); //     if (removedOnServer) .... } 
```
Parent.OnSynchronize माध्यम से, नोड सूची घटना का एक अद्यतन होता है।
Parent.OnSynchronize संसाधित किया Parent.OnSynchronize है और क्लाइंट ऑब्जेक्ट को हटा देता है।
async OnClickRemoveNode() पहले await बाद निष्पादित करना जारी रखता है और पहले से मौजूद async OnClickRemoveNode() ऑब्जेक्ट को हटाने का प्रयास किया जाता है।

आप OnClickRemoveNode में क्लाइंट ऑब्जेक्ट के अस्तित्व पर एक चेक कर सकते हैं। यह एक सरलीकृत उदाहरण है और इसमें एक समान जाँच सामान्य है। लेकिन क्या होगा अगर कॉल श्रृंखला अधिक जटिल है? इसलिए, प्रत्येक await बाद एक समान दृष्टिकोण का उपयोग करना बुरा अभ्यास है:

इतना फूला हुआ कोड समर्थन और विस्तार के लिए जटिल है।
कोड इरादा के अनुसार काम नहीं करता है: OnClickRemoveNode में विलोपन OnClickRemoveNode , और क्लाइंट ऑब्जेक्ट का वास्तविक विलोपन कहीं और होता है। डेवलपर द्वारा परिभाषित अनुक्रम का उल्लंघन नहीं होना चाहिए, अन्यथा प्रतिगमन त्रुटियां होंगी।
यह पर्याप्त विश्वसनीय नहीं है: यदि आप कहीं चेक करना भूल जाते हैं, तो एक त्रुटि होगी। खतरा यह है कि सबसे पहले, यह कि एक भूली हुई जाँच स्थानीय स्तर पर और एक परीक्षण वातावरण में त्रुटि नहीं हो सकती है, और अधिक लंबी नेटवर्क देरी वाले उपयोगकर्ताओं के लिए यह होगा।
और अगर नियंत्रक जिसके पास ये हैंडलर हैं, उसे नष्ट किया जा सकता है? प्रत्येक के बाद इसके विनाश की जांच करने के लिए await कर रहा है

एक और सवाल उठता है: क्या होगा अगर समान प्रतिस्पर्धात्मक तरीके हैं? कल्पना कीजिए कि और भी हैं:

एक नोड जोड़ना
नोड अपडेट
लिंक जोड़ें / निकालें
एकाधिक नोड रूपांतरण विधि
आवेदन का जटिल व्यवहार: हम एक नोड की स्थिति को बदलते हैं और सर्वर उस पर निर्भर नोड्स को अपडेट करना शुरू कर देता है।

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

हम ऐसे डेकोरेटर्स की आवश्यकताओं और प्रमुख विशेषताओं को रेखांकित करते हैं:

अंदर, अतुल्यकालिक कार्यों के लिए कॉल की एक पंक्ति को लागू किया जाना चाहिए। डेकोरेटर के प्रकार के आधार पर, एक फ़ंक्शन कॉल को पंक्तिबद्ध या अस्वीकृत किया जा सकता है यदि उसमें अन्य कॉल हैं।
चिह्नित कार्यों को कतार में बांधने के लिए एक निष्पादन संदर्भ की आवश्यकता होगी। आपको या तो स्पष्ट रूप से एक कतार बनानी होगी, या यह स्वचालित रूप से उस व्यू के आधार पर करना होगा जो नियंत्रक का है।
नियंत्रक उदाहरण के विनाश पर जानकारी आवश्यक है (उदाहरण के लिए, IsDestroyed संपत्ति)। नियंत्रक नष्ट होने के बाद सज्जाकारों को कतारबद्ध कॉल करने से रोकने के लिए।
व्यू कंट्रोलर के लिए, जब कतार निष्पादित होती है और नेत्रहीन रूप से प्रगति का संकेत मिलता है, तो हम क्रियाओं को बाहर करने के लिए पारभासी मास्क लगाने की कार्यक्षमता जोड़ते हैं।
सभी डेकोरेटर को Promise.done() को कॉल के साथ समाप्त होना चाहिए। इस पद्धति में, आपको बिना किसी अपवाद के handler को लागू करने की आवश्यकता है। एक बहुत ही उपयोगी चीज:
- Promise में होने वाले अपवादों को मानक त्रुटि हैंडलर द्वारा नहीं पकड़ा जाता है (जो, उदाहरण के लिए, पाठ के साथ एक विंडो और एक स्टैक ट्रेस प्रदर्शित करता है), इसलिए आप उन्हें नोटिस नहीं कर सकते हैं (यदि आप विकास के दौरान हर समय कंसोल की निगरानी नहीं करते हैं)। और उपयोगकर्ता उन्हें बिल्कुल नहीं देखेगा - इससे समर्थन मुश्किल हो जाएगा। ध्यान दें: unhandledrejection इवेंट को unhandledrejection करना सब्सक्राइब करना संभव है, लेकिन फिर भी केवल क्रोम और एज ही इसे सपोर्ट करते हैं:
```
 window.addEventListener('unhandledrejection', function(event) { // handling... }); 
```
- चूँकि हम डेकोरेटर के रूप में उच्चतम async ईवेंट हैंडलर फ़ंक्शन को चिह्नित करते हैं, इसलिए हमें संपूर्ण स्टैक ट्रेस त्रुटि मिलती है।

अब हम विवरण के साथ ऐसे सज्जाकारों की एक अनुमानित सूची देते हैं और फिर दिखाते हैं कि उन्हें कैसे लागू किया जा सकता है।

 /** * : * 1.      * 2.      ,   . * *  ,  :   ,         */ @Lock /** * : *     ,     . * *  ,     :   ,   . */ @LockQueue /** *  LockQueue .  -         * *   ,       . ,   . */ @LockBetween /** * : *       ,   . *     . :     ,     300 .       . */ @LockDeferred(300) // ,    ,     : interface ILockTarget { /** * ,   View,   .   ,        ,     ,        */ GetControllerView?(): IView; /**  true     */ IsDestroyed: boolean; }

विवरण काफी सारगर्भित हैं, लेकिन जैसे ही आप स्पष्टीकरण के साथ उपयोग का एक उदाहरण देखते हैं, सब कुछ स्पष्ट हो जाएगा:

 class GraphController implements ILockTarget { /** ,      .      */ private View: IView; public GetControllerView(): IView { return this.View; } /**      . */ @Lock private async OnClickRemoveNode(): Promise<void> { ... } /**     . */ @Lock private async OnClickRemoveLink(): Promise<void> { ... } /**     */ @Lock private async OnClickAddNewNode(): Promise<void> { ... } /**    " " */ @LockQueue private async OnServerUpdateNode(): Promise<void> { ... } /**    " " */ @LockQueue private async OnServerAddLink(): Promise<void> { ... } /**    " " */ @LockQueue private async OnServerAddNode(): Promise<void> { ... } /**    -   */ @LockQueue private async OnServerRemoveNode(): Promise<void> { ... } /**    -       */ @LockBetween private async OnServerSynchronize(): Promise<void> { ... } /**    -    (/warning/error/...) */ @LockQueue private async OnServerUpdateNodeStatus(): Promise<void> { ... } /**       */ @LockDeferred(300) private async OnSearchFieldChange(): Promise<void> { ... } }

अब हम संभावित त्रुटियों के विशिष्ट परिदृश्यों और सज्जाकारों द्वारा उनके उन्मूलन का विश्लेषण करेंगे:

उपयोगकर्ता एक कार्रवाई शुरू करता है: OnClickRemoveNode , OnClickRemoveLink । उचित प्रसंस्करण के लिए, यह आवश्यक है कि कतार में (या तो क्लाइंट या सर्वर) कोई अन्य निष्पादित हैंडलर नहीं हैं। अन्यथा, उदाहरण के लिए, ऐसी त्रुटि संभव है:
- क्लाइंट पर मॉडल अभी भी वर्तमान सर्वर स्थिति में अपडेट किया जाता है
- हम अद्यतन के पूरा होने से पहले ऑब्जेक्ट को हटाने की पहल करते हैं (कतार में OnServerSynchronize में एक OnServerSynchronize हैंडलर है)। लेकिन यह ऑब्जेक्ट वास्तव में अब नहीं है - बस पूर्ण सिंक्रनाइज़ेशन अभी तक पूरा नहीं हुआ है और यह अभी भी क्लाइंट पर प्रदर्शित होता है।
  इसलिए, उपयोगकर्ता द्वारा शुरू की गई सभी क्रियाएं, Lock डेकोरेटर को अस्वीकार कर देना चाहिए यदि कतार में अन्य हैंडलर समान कतार संदर्भ के साथ हैं। यह देखते हुए कि सर्वर अतुल्यकालिक है, यह विशेष रूप से महत्वपूर्ण है। हां, Websocket क्रमिक रूप से अनुरोध भेजता है, लेकिन यदि क्लाइंट अनुक्रम को तोड़ता है, तो हमें सर्वर पर एक त्रुटि मिलती है।
हम एक नोड के अलावा आरंभ करते हैं: OnClickAddNewNode । OnServerSynchronize , OnServerAddNode ईवेंट सर्वर से आते हैं।
- OnClickAddNewNode ने कतार OnClickAddNewNode (यदि इसमें कुछ था, तो इस विधि का Lock डेकोरेटर कॉल को अस्वीकार कर देगा)
- OnClickAddNewNode , OnClickAddNewNode OnServerAddNode , OnClickAddNewNode बाद क्रमिक रूप से निष्पादित, इसके साथ प्रतिस्पर्धा नहीं।
कतार में OnServerSynchronize और OnServerUpdateNode । मान लीजिए कि पहले निष्पादन के दौरान, उपयोगकर्ता GraphController बंद कर देता है। फिर OnServerUpdateNode दूसरी कॉल स्वचालित रूप से नहीं की जानी चाहिए ताकि नष्ट नियंत्रक पर कार्रवाई न हो, जो एक त्रुटि का कारण बनने की गारंटी है। इसके लिए, ILockTarget इंटरफ़ेस में IsDestroyed - सज्जाकार कतार से अगले हैंडलर को निष्पादित किए बिना ध्वज की जांच करता है।
लाभ: प्रत्येक await बाद if (!this.IsDestroyed()) लिखने की कोई आवश्यकता नहीं है।
कई नोड्स में परिवर्तन शुरू हो जाता है। OnServerSynchronize , OnServerUpdateNode ईवेंट सर्वर से आते हैं। उनके प्रतिस्पर्धी निष्पादन से अपूरणीय त्रुटियां होंगी। लेकिन कब से LockQueue वे LockQueue और LockBetween द्वारा चिह्नित हैं, LockQueue उन्हें क्रमिक रूप से निष्पादित किया जाएगा।
कल्पना करें कि नोड्स के अंदर नेस्टेड नोड ग्राफ हो सकते हैं। GraphController #1 , — GraphController #2 . , GraphController - , ( — ), .. . :
- GraphController #2 , , .
OnSearchFieldChange , . - . @LockDeferred(300) 300 : , , 300 . , . :
- , 500 , . — OnSearchFieldChange , .
- OnSearchFieldChange — , .

Deadlock: Handler1 , , await Handler2 , LockQueue , Handler2 — Handler1 .
, View . : , — .

, , . :

- <Class> . <Method> => <Time> ( ).
.
.

, , , . ? ? :

 class GraphController implements ILockTarget { private View: IView; public GetControllerView(): IView { return this.View; } /**     . */ @Lock private async RunBigDataCalculations(): Promise<void> { await Start(); await UpdateSmth(); await End(); await CleanUp(); } /**   . */ @LockQueue private async OnChangeNodeState(node: INode): Promise<void> { await GetNodeData(node); await UpdateNode(node); } }

RunBigDataCalculations .
await Start();
/ ( )
await Start(); , await UpdateSmth(); .

RunBigDataCalculations .
OnChangeNodeState , (.. ).
await GetNodeData(node);
/ ( )
await GetNodeData(node); , await UpdateNode(node); .

- . :

 /** *       ,      */ export interface IQueuedDisposableLockTarget extends ILockTarget { /**     . Lock          IsDisposing() === true */ IsDisposing(): boolean; SetDisposing(): void; }

 function QueuedDispose(controller: IQueuedDisposableLockTarget): void { //      let xQueue = GetQueue(controller); // 1. ,     -,   -   if (xQueue.Empty) { controller.Dispose(); return; } // 2.  ,     " ",     ,   . controller.SetDisposing(); // 3.   finally   xQueue.finally(() => { debug.assert(!IsDisposed(controller), "-      ,  "); controller.Dispose(); }); }

, . QueuedDispose :

. .
QueuedDispose controller . — ExtJS .

, , .. . , ? , .

, :

vk.com
Telegram

अमीर इंटरनेट अनुप्रयोग और सज्जाकार में अतुल्यकालिक टाइपस्क्रिप्ट यह मुकाबला करने के लिए

सर्वर से प्राप्त डेटा कैसे संरचित है

क्लाइंट को डेटा कैसे प्राप्त होता है

एक "कॉलबैक हेल" के बिना अतुल्यकालिक।

क्वेरी भाषा

रेस की स्थिति और समाधान

More articles: