😖 👛 🥔 .NET मल्टीथ्रेडिंग: जब प्रदर्शन में कमी होती है ✌🏿 👩🏼‍🤝‍👨🏽 ✌🏾

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

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

Cutscene के तहत DotNext कॉन्फ्रेंस से मेरी रिपोर्ट का एक वीडियो और ट्रांसक्रिप्ट है, जहां मैं मानक .NET लाइब्रेरी के टूल का उपयोग करते समय कुछ उदाहरणों का विश्लेषण करता हूं (Task.Delay, SemaphoreSlim, ConcurrentDictionary) ने प्रदर्शन ड्रॉप का नेतृत्व किया, और मैं विशिष्ट कार्यों के लिए तैयार किए गए समाधानों का प्रस्ताव रखता हूं और विशिष्ट कार्यों से रहित हूं। इन कमियों।

रिपोर्ट के समय, उन्होंने कोंतूर में काम किया। कोंटूर व्यवसाय के लिए विभिन्न अनुप्रयोगों को विकसित करता है, और मैंने जिस टीम में बुनियादी ढांचे के साथ काम किया है और विभिन्न समर्थन सेवाओं और पुस्तकालयों को विकसित करता है जो अन्य टीमों में डेवलपर्स को उत्पाद सेवाएं बनाने में मदद करते हैं।

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

आज हम किस बारे में बात करने जा रहे हैं?

.NET में Multithreading और Asynchrony;
स्टैकिंग सिंक्रोनाइज़ेशन प्राइमेटीज़ और संग्रह;
यदि मानक दृष्टिकोण लोड के साथ सामना नहीं कर सकता है तो क्या करें?

आइए .NET में मल्टीथ्रेड और एसिंक्रोनस कोड के साथ काम करने की कुछ विशेषताओं का विश्लेषण करें। आइए कुछ सिंक्रनाइज़ेशन प्राइमेटीज़ और समवर्ती संग्रह को देखें, देखें कि वे अंदर कैसे व्यवस्थित होते हैं। हम इस बात पर चर्चा करेंगे कि यदि पर्याप्त कक्षाएं नहीं होती हैं, तो क्या करना है, अगर मानक कक्षाएं भार का सामना नहीं कर सकती हैं, और क्या इस स्थिति में कुछ किया जा सकता है।

मैं आपको चार कहानियां बताऊंगा जो हमारे उत्पादन स्थल पर हुई थीं।

इतिहास 1: टास्क.डेले और टिमरक्यू

यह कहानी पहले से ही काफी प्रसिद्ध है, इसके बारे में पिछले DotNext में शामिल है। हालांकि, इसे एक दिलचस्प सीक्वेल मिला, इसलिए मैंने इसे जोड़ा। तो क्या बात है?

1.1 मतदान और लंबा मतदान

सर्वर लंबे ऑपरेशन करता है, क्लाइंट उनका इंतजार करता है।
पोलिंग: क्लाइंट समय-समय पर सर्वर से रिजल्ट के बारे में पूछता है।
लंबा मतदान: क्लाइंट एक लंबे टाइमआउट के साथ एक अनुरोध भेजता है, और ऑपरेशन पूरा होने पर सर्वर प्रतिक्रिया करता है।

फायदे:

कम यातायात
क्लाइंट तेजी से परिणाम के बारे में सीखता है

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

पहला तरीका मतदान है । क्लाइंट सर्वर पर कार्य शुरू करता है, फिर समय-समय पर इस कार्य की स्थिति की जांच करता है, जबकि सर्वर कार्य की स्थिति ("पूरा हुआ" / "पूरा नहीं हुआ" / "एक त्रुटि के साथ पूरा हुआ") वापस कर देता है। क्लाइंट समय-समय पर रिजल्ट आने तक रिक्वेस्ट भेजता है।

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

टास्क: टाइमआउट
हम टाइमआउट के साथ टास्क का इंतजार करना चाहते हैं
Senditync प्रतीक्षा करें ();

उदाहरण के लिए, हमारे पास एक टास्क है जो सर्वर को एक अनुरोध भेजता है, और हम एक टाइमआउट के साथ इसके परिणाम की प्रतीक्षा करना चाहते हैं, अर्थात, हम या तो इस टास्क का परिणाम वापस करेंगे या किसी प्रकार की त्रुटि भेजेंगे। सी # कोड इस तरह दिखेगा:

var sendTask = SendAsync(); var delayTask = Task.Delay(timeout); var task = await Task.WhenAny(sendTask, delayTask); if (task == delayTask) return Timeout;

यह कोड हमारे टास्क को लॉन्च करता है, जिसके परिणाम की हम प्रतीक्षा करना चाहते हैं, और टास्क। इसके बाद, Task.WhenAny का उपयोग करते हुए, हम या तो हमारे टास्क या टास्क का इंतजार कर रहे हैं। यदि यह पता चला है कि टास्क। डेल को पहले निष्पादित किया गया है, तो समय समाप्त हो गया है और हमारे पास समय समाप्त हो गया है, हमें एक त्रुटि वापस करनी चाहिए।

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

1.2 लंबे मतदान के साथ समस्याएं

बड़े टाइमआउट
कई समवर्ती प्रश्न
=> उच्च CPU उपयोग

इस मामले में, समस्या प्रोसेसर संसाधनों की उच्च खपत है। ऐसा हो सकता है कि प्रोसेसर पूरी तरह से 100% पर भरा हुआ है, और एप्लिकेशन आमतौर पर काम करना बंद कर देता है। ऐसा लगता है कि हम प्रोसेसर संसाधनों का उपभोग नहीं करते हैं: हम कुछ अतुल्यकालिक संचालन करते हैं, सर्वर से प्रतिक्रिया की प्रतीक्षा करते हैं, और प्रोसेसर अभी भी हमारे साथ भरा हुआ है।

जब हमने इस स्थिति का सामना किया, तो हमने अपने एप्लिकेशन से मेमोरी डंप हटा दिया:

  ~*e!clrstack System.Threading.Monitor.Enter(System.Object) System.Threading.TimerQueueTimer.Change(…) System.Threading.Timer.TimerSetup(…) System.Threading.Timer..ctor(…) System.Threading.Tasks.Task.Delay(…)

डंप का विश्लेषण करने के लिए, हमने WinDbg टूल का उपयोग किया। हमने एक कमांड दर्ज किया जो सभी प्रबंधित थ्रेड्स के स्टैक के निशान दिखाता है, और ऐसा परिणाम देखा। हमारे पास प्रक्रिया में बहुत सारे धागे हैं जो कुछ लॉक पर इंतजार कर रहे हैं। मॉनिटर.इंटर विधि वह है जो C # में लॉक का निर्माण करती है। इस लॉक को टाइमर और टिमरक्यूयूटीमर नामक कक्षाओं के अंदर कैद किया गया है। टाइमर में, हम टास्क से आए थे। तब जब हमने उन्हें बनाने की कोशिश की। यह क्या है? जब Task.Delay शुरू होता है, तो TimerQueue के अंदर लॉक कैप्चर किया जाता है।

1.3 ताला काफिला

कई धागे एक ताला बंद करने की कोशिश करते हैं
लॉक के तहत, थोड़ा कोड निष्पादित किया जाता है
समय थ्रेड सिंक्रोनाइज़ेशन पर खर्च किया जाता है, कोड निष्पादन पर नहीं।
थ्रेडब्लॉक अवरुद्ध हैं - वे अनंत नहीं हैं

हमारे पास आवेदन में लॉक काफिला था। कई धागे एक ही लॉक को पकड़ने की कोशिश करते हैं। इस लॉक के तहत, कोड का एक बहुत निष्पादित होता है। यहां संसाधन संसाधन एप्लिकेशन कोड पर ही खर्च नहीं किए जाते हैं, लेकिन इस लॉक पर आपस में थ्रेड को सिंक्रनाइज़ करने के लिए ऑपरेशन पर। यह .NET से संबंधित एक विशेषता को भी ध्यान देने योग्य है: लॉक काफिले में भाग लेने वाले धागे थ्रेड पूल से थ्रेड होते हैं।

तदनुसार, यदि थ्रेड पूल से थ्रेड्स अवरुद्ध हैं, तो वे समाप्त हो सकते हैं - थ्रेड पूल में थ्रेड्स की संख्या सीमित है। इसे कॉन्फ़िगर किया जा सकता है, लेकिन अभी भी एक ऊपरी सीमा है। यह पूरा हो जाने के बाद, सभी थ्रेडपूल थ्रेड लॉक काफिले में भाग लेंगे, और थ्रेडपुल को शामिल करने वाला कोई भी कोड एप्लिकेशन में निष्पादित नहीं होगा। इससे स्थिति बहुत खराब हो जाती है।

१.४ टिमरक्यू

किसी .NET अनुप्रयोग में टाइमर का प्रबंधन करता है।
टाइमर का उपयोग किया जाता है:
- कार्य
- रद्द करने के लिए
- HttpClient

TimerQueue एक वर्ग है जो .NET अनुप्रयोग में सभी टाइमर का प्रबंधन करता है। यदि आप एक बार WinForms में प्रोग्राम करते हैं, तो आपने मैन्युअल रूप से टाइमर बनाए होंगे। उन लोगों के लिए जो यह नहीं जानते हैं कि टाइमर क्या हैं: उनका उपयोग टास्क में किया जाता है। डेलय (यह सिर्फ हमारा मामला है), उन्हें कैंसिलेशनटोकन के अंदर भी रद्द किया गया। यही है, टास्कडेल को रद्द करना रद्द करने के साथ टास्कलेन। कांकेले के बाद किसी भी तरह से हमारी मदद नहीं करेगा। इसके अलावा, कई आंतरिक .NET कक्षाओं में टाइमर का उपयोग किया जाता है, उदाहरण के लिए, HttpClient में।

जहाँ तक मुझे पता है, HttpClient हैंडलर्स के कुछ कार्यान्वयन में टाइमर हैं। यहां तक कि अगर आप उन्हें स्पष्ट रूप से उपयोग नहीं करते हैं, तो टास्क शुरू न करें। सबसे अधिक संभावना है, आप अभी भी वैसे भी उनका उपयोग करते हैं।

अब आइए देखें कि टिमेरक्यू को अंदर कैसे व्यवस्थित किया जाता है।

वैश्विक राज्य (प्रति-अनुगामी):
- TimerQueueTimer की डबल लिंक्ड सूची
- ताला वस्तु
नियमित टाइमर कॉलबैक
प्रतिक्रिया समय द्वारा टाइमर का आदेश नहीं दिया गया
टाइमर जोड़ना: O (1) + लॉक
टाइमर हटाना: O (1) + लॉक
प्रारंभ टाइमर: O (N) + लॉक

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

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

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

क्या स्थिति हो सकती है? हमारे पास टिमरक्यू में बहुत सारी इमारते हैं, इसलिए जब रूटीन शुरू होता है, तो यह अपने लंबे रैखिक ऑपरेशन को बंद कर देता है, उस समय जो लोग टिमरक्यू से टाइमर शुरू करने या हटाने की कोशिश करते हैं, वे इसके बारे में कुछ नहीं कर सकते। इस वजह से, लॉक काफिला होता है। यह समस्या .NET कोर में ठीक की गई है।

टाइमर लॉक विवाद को कम करें (coreclr # 14527)
ताला लगाने का काम
- एनवायरनमेंट।प्रोसेसर Count TimerQueue's TimerQueueTimer
छोटे / लंबे समय तक रहने वाले टाइमर के लिए अलग-अलग कतारें
लघु टाइमर: समय <= 1/3 सेकंड

https://github.com/dotnet/coreclr/issues/14462
https://github.com/dotnet/coreclr/pull/14527

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

.NET कोर में भी कुछ अनुकूलन लागू किए गए। टाइमर को लंबे समय तक जीवित और अल्पकालिक में विभाजित किया गया था, उनके लिए अब अलग-अलग टिमरक्यू का उपयोग किया जाता है। अल्पकालिक टाइमर को सेकंड के 1/3 से कम होने के लिए चुना जाता है। मुझे नहीं पता कि ऐसा स्थिरांक क्यों चुना गया था। .NET कोर में, हम टाइमर के साथ समस्याओं को पकड़ने में विफल रहे।

https://github.com/Microsoft/dotnet-framework-early-access/blob/master/release-notes/NET48/dotnet-48-changes.md
https://github.com/dotnet/coreclr/labels/netfx-port-consider

यह फिक्स .NET फ्रेमवर्क, संस्करण 4.8 में बैकपोर्ट किया गया था। Netfx-port-गौर टैग ऊपर दिए गए लिंक में इंगित किया गया है, यदि आप .NET कोर, CoreCLR, CoreFX रिपॉजिटरी में जाते हैं, तो आप इस मुद्दे को खोज सकते हैं। जो .NET फ्रेमवर्क में बैकपोर्ट किया जाएगा, अब उनमें से लगभग पचास हैं। यही है, खुले स्रोत .NET ने बहुत मदद की, काफी कुछ कीड़े तय किए गए थे। आप चेंजलॉग .NET फ्रेमवर्क 4.8 पढ़ सकते हैं: बहुत सारे बग फिक्स किए गए हैं, अन्य .NET रिलीज की तुलना में बहुत अधिक है। दिलचस्प बात यह है कि यह फ्रेमवर्क .NET फ्रेमवर्क 4.8 में डिफ़ॉल्ट रूप से बंद है। यह पूरी फ़ाइल में शामिल है जिसे आप App.config कहते हैं

इस फिक्स को सक्षम करने वाले App.config में सेटिंग को UseNetCoreTimer कहा जाता है। .NET फ्रेमवर्क 4.8 आने से पहले, हमारे आवेदन के काम करने और लॉक काफिले में न जाने के लिए, आपको Task.Delay के अपने कार्यान्वयन का उपयोग करना था। इसमें, हमने बाइनरी हीप का उपयोग करने का प्रयास किया ताकि अधिक कुशलता से समझ सकें कि किस समय टाइमर को बुलाया जाना चाहिए।

1.5 टास्क। डेलय: देशी कार्यान्वयन

BinaryHeap
Sharding
इसने मदद की, लेकिन सभी मामलों में नहीं

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

१.६ टास्कडेल। निष्कर्ष: निष्कर्ष

हर जगह नुकसान - यहां तक कि सबसे ज्यादा इस्तेमाल की जाने वाली चीजों में भी
तनाव परीक्षण करें
कोर पर स्विच करें, पहले बग को ठीक करें (और नए बग) :)

इस पूरी कहानी से क्या निष्कर्ष निकलता है? सबसे पहले, नुकसान हर जगह वास्तव में स्थित हो सकते हैं, यहां तक कि उन कक्षाओं में भी जो आप बिना सोचे-समझे हर दिन का उपयोग करते हैं, उदाहरण के लिए, एक ही कार्य, टास्क।

मैं आपके प्रस्तावों का तनाव परीक्षण करने की सलाह देता हूं। यह समस्या हमने सिर्फ लोड टेस्टिंग के चरण में पहचानी। फिर हमने इसे अन्य अनुप्रयोगों में उत्पादन पर कई बार शूट किया, लेकिन फिर भी, तनाव परीक्षण ने हमें वास्तविकता में इस समस्या का सामना करने से पहले समय में देरी करने में मदद की।

.NET कोर पर स्विच करें - आप बग फिक्स (और नए बग) प्राप्त करने वाले पहले व्यक्ति होंगे। नए बग के बिना कहाँ?

टाइमर के बारे में कहानी खत्म हो गई है, और हम अगले पर चलते हैं।

कहानी २: सेमफोरस्लीम

निम्नलिखित कहानी प्रसिद्ध सेमाफोरस्लीम के बारे में है।

2.1 सर्वर थ्रॉटलिंग

सर्वर पर समवर्ती संसाधित अनुरोधों की संख्या को सीमित करना आवश्यक है

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

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

बेशक, यह सिर्फ इतना है कि सेमाफोर हमारे लिए बहुत उपयुक्त नहीं है, यह .NET सिंक्रोनस में है, इसलिए हमने सेमफोरस्लीम लिया और यह कोड लिखा:

 var semaphore = new SemaphoreSlim(N); … await semaphore.WaitAsync(); await HandleRequestAsync(request); semaphore.Release();

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

2.2 सर्वर थ्रॉटलिंग: जटिलता

LIFO आदेश में प्रसंस्करण अनुरोध
SemaphoreSlim
ConcurrentStack
TaskCompletionSource

हम व्यापार तर्क के बारे में थोड़ा भूल गए। थ्रॉटलिंग के लिए आने वाले अनुरोध वास्तविक http अनुरोध हैं। एक नियम के रूप में, उनके पास कुछ समयबाह्य है, जो उन लोगों द्वारा निर्धारित किया जाता है जिन्होंने यह अनुरोध स्वचालित रूप से भेजा है, या कुछ समय के बाद F5 दबाने वाले उपयोगकर्ता का समय समाप्त हो गया है। तदनुसार, यदि आप एक नियमित रूप से सेमाफोर की तरह, कतार क्रम में अनुरोधों को संसाधित करते हैं, तो सबसे पहले कतार से उन सभी अनुरोधों का समय समाप्त हो सकता है जो पहले से ही संसाधित हो सकते हैं। यदि आप स्टैक ऑर्डर में काम करते हैं - उन सभी अनुरोधों में से सबसे पहले प्रक्रिया करें जो बहुत अंतिम समय में आए, ऐसी समस्या उत्पन्न नहीं होगी।

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

हम सभी ने इसे लागू किया है। कोड भयानक है। और, सबसे बुरा, यह निष्क्रिय हो गया।

इसके बजाय एक भारी लोड किए गए एप्लिकेशन में इसके उपयोग की शुरुआत के कुछ महीने बाद, हमें एक समस्या का सामना करना पड़ा। पिछले मामले की तरह ही, सीपीयू की खपत बढ़कर 100% हो गई है। हमने ऐसा ही किया, डंप को हटा दिया, विनडबग में इसे देखा, और फिर से लॉक काफिला मिला।

इस बार लॉक काफिला सेमफोरस्लाइम.वेलिट्ससुंक और सेमफोरस्लीम.लीज के अंदर हुआ। यह पता चला कि सेमफोरस्लीम के अंदर एक ताला है, यह लॉक-फ्री नहीं है। यह हमारे लिए एक गंभीर समस्या थी।

सेमाफोरस्लीम के अंदर एक आंतरिक स्थिति होती है (कितने कर्मचारी अभी भी इसके तहत जा सकते हैं) का एक काउंटर है, और इस सेमाफोर पर इंतजार कर रहे लोगों की एक डबल लिंक की गई सूची है। यहां विचार समान हैं: आप इस सेमाफोर पर इंतजार कर सकते हैं, आप अपनी उम्मीद को रद्द कर सकते हैं - इस कतार को छोड़ने के लिए। एक ताला है जिसने बस हमारे जीवन को बर्बाद कर दिया है।

हमने फैसला किया: सभी भयानक कोड के साथ जो हमें लिखना था।

आइए हमारे सेमीफोर को लिखते हैं, जो तुरंत लॉक-फ्री होगा और जो तुरंत स्टैक ऑर्डर में काम करेगा। प्रतीक्षा को रद्द करना हमारे लिए महत्वपूर्ण नहीं है।

इस स्थिति को परिभाषित करें। यहां नंबर करेंट-कॉउंट होगा - यह है कि सेमफोर में कितने और स्थान बचे हैं। यदि सेमाफोर में सीटें नहीं बची हैं, तो यह संख्या नकारात्मक होगी और यह दर्शाएगी कि कितने कार्यकर्ता कतार में हैं। एक समवर्ती स्टाॅक भी होगा, जिसमें टास्क कॉमप्लेक्शनस्रोसोव शामिल है - यह वेटर'ओव का एक स्टैक है, जहां से यदि आवश्यक हो तो उन्हें खींच लिया जाएगा। चलिए WaitAsync विधि लिखते हैं।

 var decrementedCount = Interlocked.Decrement(ref currentCount); if (decrementedCount >= 0) return Task.CompletedTask; var waiter = new TaskCompletionSource<bool>(); waiters.Push(waiter); return waiter.Task;

सबसे पहले, हम काउंटर को कम करते हैं, अपने लिए सेमाफोर में एक जगह लेते हैं, अगर हमारे पास मुफ्त स्थान थे, और फिर हम कहते हैं: "यह बात है, आप सेमीफोर के तहत गए थे"।

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

अब हम रिलीज़ विधि लिखते हैं।

 var countBefore = Interlocked.Increment(ref currentCount) - 1; if (countBefore < 0) { if (waiters.TryPop(out var waiter)) waiter.TrySetResult(true); }

रिलीज विधि इस प्रकार है:

सेमाफोर में एक सीट
इंक्रीमेंट करंट

यदि हम currentCount द्वारा बता सकते हैं कि क्या स्टैक के अंदर वेटर हैं जिनके बारे में हमें संकेत देने की आवश्यकता है, तो हम ऐसे वेटर को स्टैक और सिग्नल से बाहर निकालते हैं। यहाँ वेटर एक TaskCompletionSource है। इस कोड पर सवाल: यह तर्कसंगत लगता है, लेकिन क्या यह भी काम करता है? क्या समस्याएं हैं? निरंतरता से संबंधित एक बारीकियां है, जहां 'TaskCompletionSource'y' को लॉन्च किया जाता है।

इस कोड पर विचार करें। हमने एक TaskCompletionSource बनाया और दो टास्क लॉन्च किए। पहला टास्क एक यूनिट प्रदर्शित करता है, परिणाम को टास्क कॉमप्लेक्शन स्रोत पर सेट करता है, और फिर कंसोल पर एक ड्यूस प्रदर्शित करता है। दूसरा टास्क इस टास्क कॉमप्लेक्शन सोर्स पर इंतजार करता है, इसके टास्क पर, और फिर हमेशा थ्रेड पूल से इसके थ्रेड को ब्लॉक करता है।

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

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

 var tcs = new TaskCompletionSource<bool>( TaskCreationOptions.RunContinuationsAsynchronously); /* OR */ Task.Run(() => tcs.TrySetResult(true));

इस समस्या को हल करने के लिए, हम या तो संबंधित RunContinuationsAsynchronously ध्वज के साथ एक टास्ककॉमप्लेक्शन स्रोत बना सकते हैं, या टास्क के अंदर TrySetResult विधि को कॉल कर सकते हैं। Run/ThreadPool.QueueUserWebItem ताकि यह हमारे धागे पर न चले। यदि इसे हमारे धागे पर लागू किया जाता है, तो हमारे पास अवांछित दुष्प्रभाव हो सकते हैं। इसके अलावा, एक दूसरी समस्या है, हम इस पर अधिक विस्तार से ध्यान देंगे।

WaitAsync और रिलीज़ विधियों को देखें और रिलीज़ विधि में एक और समस्या खोजने का प्रयास करें।

सबसे अधिक संभावना है, उसे बस इतना असंभव खोजने के लिए। यहां एक दौड़ है।

यह इस तथ्य के कारण है कि WaitAsync विधि में राज्य परिवर्तन परमाणु नहीं है। पहले हम काउंटर को घटाते हैं और उसके बाद ही स्टैक पर वेटर को धक्का देते हैं। यदि ऐसा होता है कि रिलीज में कमी और धक्का के बीच निष्पादन किया जाता है, तो यह बाहर निकल सकता है ताकि यह स्टैक से बाहर कुछ भी न खींचे। इसे ध्यान में रखा जाना चाहिए, और रिलीज़ विधि में, स्टैक पर वेटर के प्रकट होने की प्रतीक्षा करें।

 var countBefore = Interlocked.Increment(ref currentCount) - 1; if (countBefore < 0) { Waiter waiter; var spinner = new SpinWait(); while (!waiter.TryPop(out waiter)) spinner.SpinOnce(); waiter.TrySetResult(true); }

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

पहले कुछ पुनरावृत्तियों में, यह एक लूप में स्पिन करेगा। यदि बहुत अधिक पुनरावृत्तियां हैं, तो वेटर लंबे समय तक दिखाई नहीं देगा, फिर हमारा धागा थ्रेड सो जाएगा। ताकि सीपीयू संसाधनों को एक बार फिर से बर्बाद न करें।

वास्तव में, LIFO- ऑर्डर सेमाफोर केवल हमारा विचार नहीं है।

LowLevelLifoSemaphore
एक समय का
विंडोज पर विंडोज स्टैक के रूप में IO कम्पेक्शन पोर्ट का उपयोग करता है

https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.cs

.NET में ही ऐसा सेमाफोर है, लेकिन CoreCLR में नहीं, CoreFX में नहीं, बल्कि CoreRT में। यह कभी-कभी .NET रिपॉजिटरी में आने के लिए काफी उपयोगी है। एक सेमाफोर है जिसे लोवेलवेलिफोसेमाफोर कहा जाता है। यह सेमाफोर हमें वैसे भी सूट नहीं करेगा: यह सिंक्रोनस है।

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

2.3 निष्कर्ष:

उम्मीद न करें कि आपके लोड के तहत ढांचे को भरना बच जाएगा
सामान्य मामले की तुलना में एक विशिष्ट समस्या को हल करना आसान है।
तनाव परीक्षण हमेशा मदद नहीं करता है
ब्लॉक करने से सावधान रहें

इस पूरी कहानी से क्या निष्कर्ष निकलता है? सबसे पहले, यह आशा न करें कि मानक पुस्तकालय से आपके द्वारा उपयोग की जाने वाली रूपरेखा से कुछ कक्षाएं आपके भार का सामना करेंगी। मैं यह नहीं कहना चाहता कि सेमाफोरस्लिम खराब है, यह इस परिदृश्य में विशेष रूप से अनुपयुक्त है।

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

लोड परीक्षण, हालांकि यह मदद करता है, हमेशा मदद नहीं कर सकता है।

.NET , — . lock, : « ?» CPU 100%, lock', , , - .NET. .

.

3: (A)sync IO

/, .

lock convoy, stack trace Overlapped PinnableBufferCache. lock. : Overlapped PinnableBufferCache?

OVERLAPPED — Windows, /. , . , . , lock convoy. , lock convoy, , .

, , .NET 4.5.1 4.5.2. .NET 4.5.2, , .NET 4.5.2. .NET 4.5.1 OverlappedDataCache, Overlapped — , , . , lock-free, ConcurrentStack, . .NET 4.5.2 : OverlappedDataCache PinnableBufferCache.

? PinnableBufferCache , Overlapped , , — . , , . PinnableBufferCache . , lock-free, ConcurrentStack. , . , , - lock-free list lock'.

3.1 PinnableBufferCache

LockConvoy:

lock convoy , - . list , lock , , .

PinnableBufferCache , . :

 PinnableBufferCache_System.ThreadingOverlappedData_MinCount

, . : « ! - ». -:

 Environment.SetEnvironmentVariable( "PinnableBufferCache_System.Threading.OverlappedData_MinCount", "10000"); new Overlapped().GetHashCode(); for (int i = 0; i < 3; i++) GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);

? , Overlapped , , . , , , , PinnableBufferCache lock convoy'. , .

.NET Core PinnableBufferCache , OverlappedData . , , Garbage collector , . .NET Core . .NET Framework, , .

3.2 :

.NET Core

, . , .NET , . , , .NET Core. , , -.

key-value .

4: Concurrent key-value collections

.NET concurrent-. lock-free ConcurrentStack ConcurrentQueu, . ConcurrentDictionary, . lock-free , , . ConcurrentDictionary?

4.1 ConcurrentDictionary

पेशेवरों:

(TryAdd/TryUpdate/AddOrUpdate)
Lock-free
Lock-free enumeration

, memory-, , . , , .NET Framework. . , , (enumeration) lock-free. , .

, , - .NET. key-value - :

-, bucket'. bucket', . , bucket , .

— , ConcurrentDictionary. ConcurrentDictionary «-» . , , , memory traffic. ConcurrentDictionary, lock'. — .

, Dictionary.

Dictionary , Concurrent, . : buckets, entries. buckets bucket' entries. «-» entries. . «-» int, bucket'.

memory overhead, ConcurrentDictionary Dictionary.

Dictionary. Memory overhea' , . Dictionary overhead - , int'. 8 .

ConcurrentDictionary. ConcurrentDictionary ConcurrentDictionary.Node. , . int hashCode . , table ( 16 ), int hashCode . , 64- 28 overhead'. Dictionary.

memory overhead', ConcurrentDictionary GC , . Benchmark. ConcurrentDictionary , GC.Collect. ?

. ConcurrentDictionary 10 , , , . Dictionary . , , , . .

, ConcurrentDictionary?

4.2

TTL
Dictionary+lock
Sharding

. ConcurrentDictionary. 10 . , . TTL , . Dictionary lock'. , , lock . Dictionary lock' , - , lock. , .

4.3

in-memory <Guid,Guid>
>10 ⁶

. — , in-memory Guid' Guid, . . - - , . , 15 . . Semaphore ConcurrentDictionary.

, lock-free , overhead GC. , . , , , . , - , , . , , Large Object Heap. ?

, , Dictionary .

Dictionary bucket', Entry. Entry , , , .

Dictionary , , . , - .

, - ? -, , , , . . Dictionary, , buckets, entries, Interlocked. , .

Dictionary
,
, ?
— Resize buckets entries
— -
— Dictionary.Entry
— -

https://blogs.msdn.microsoft.com/tess/2009/12/21/high-cpu-in-net-app-using-a-static-generic-dictionary/

, Dictionary - bucket'. , . , , . , , .

Entry Dictionary. - - . , .

.NET Framework 1.1. Hashtable, Dictionary, object'. MSDN , . , -. . , Hashtable . , .

4.4 Dictionary.Entry

? Dictionary.Entry , , 8 , , , , . ?

 bool writing; int version; this.writing = true; buckets[index] = …; this.version++; this.writing = false;

: ( , ) int-. , . , , , , .

 bool writing; int version; while (true) { int version = this.version; bucket = bickets[index]; if (this.writing || version != this.version) continue; break; }

, , . , . , 8 .

4.5 -

, .

Dictionary bucket , .

Dictionary, . : 0 2. bucket, 1 2. ? 0. , , 2. . , 2, , , 1. 1 2 — bucket. , , . 1 — , bucket. Hashtable , bucket' -. — double hashing .

4.6

, resize

. , Buckets, Entries ( Buckets, Entries). - , , , , .

. , .

: , , , , . , , .

, , — .

? , - 2. - Capacity , . — 2. , . 2. ? , , , . - , , 3. , , , , , .

, Hashtable, . , double hashing. , , , .

, , — , . Hashtable. , — — . . , bucket', - , . .

, , lock-free LOH.

lock-free ? MSDN Hashtable , . , , .

, , , bucket'. Dictionary bucket', -, bucket' . - bucket, bucket . , .

, Large Object Heap.

. CustomDictionary CustomDictionarySegment . Dictionary, , . — Dictionary, . , Large Object Heap. , bucket' . , , , bucket, - - .

. ConcurrentDictionary, .NET, , .

4.7

.NET
,

? .NET . . , , . - — - . , , , .

- , , , , . , , , , , . — , , .

— ConcurrentDictionary. , , ( Diafilm ), .

GitHub. — , , LIFO-Semaphore, . , .

6-7 DotNext 2019 Moscow «.NET: » , .NET Framework .NET Core, , .

.NET मल्टीथ्रेडिंग: जब प्रदर्शन में कमी होती है