प्रॉम्प्ट और संदर्भ
यह कोडिंग प्रश्न प्रत्येक प्रॉमिस को केवल Promise.all में डालने के बजाय कंकरेंसी शेड्यूलिंग का परीक्षण करता है। उम्मीदवार को थ्रूपुट, क्रमबद्धता, एरर प्रोपेगेशन, कैंसिलेशन और खाली इनपुट के लिए एक कॉन्ट्रैक्ट परिभाषित करना होगा, और फिर यह प्रदर्शित करना होगा कि सीमा कभी पार न हो और कोई भी आइटम दो बार प्रोसेस न हो।
इंटरव्यूअर क्या मूल्यांकन करता है
- क्या फिक्स्ड वर्कर्स या समकक्ष शेड्यूलर अधिकतम N सक्रिय कार्य रखते हैं।
- क्या परिणाम इनपुट इंडेक्स के अनुसार लिखे जाते हैं ताकि पूरा होने का क्रम आउटपुट के क्रम को न बदले।
- क्या पहले से चल रहे कार्यों सहित, फेल-फास्ट और कलेक्ट-एरर्स सिमेंटिक्स स्पष्ट हैं।
- क्या अमान्य N, खाली इनपुट, सिंक्रोनस थ्रो, कैंसिलेशन, और गैर-Promise mapper वैल्यूज ठीक से काम करते हैं।
पूछने के लिए स्पष्टीकरण प्रश्न
पुष्टि करें कि क्या कैंसिलेशन के बाद कार्य जारी रह सकते हैं, क्या फेल-फास्ट क्लीनअप की प्रतीक्षा करता है, क्या आंशिक परिणाम लौटाए जाते हैं, और क्या mapper एक AbortSignal स्वीकार करता है। पुनः प्रयास (retries), डायनामिक कंकरेंसी, और मूल एरर ऑब्जेक्ट की पहचान बनाए रखने के बारे में पूछें।
30-सेकंड उत्तर ढांचा
मैं अधिकतम N वर्कर्स बनाऊंगा जो एक नेक्स्ट-इंडेक्स काउंटर साझा करते हैं। प्रत्येक वर्कर एक इंडेक्स लेता है, सिंक्रोनस रिटर्न्स और थ्रो को Promise.resolve से रैप करता है, और इंडेक्स के आधार पर लिखता है। फेल-फास्ट पहले देखे गए एरर को प्रोपेगेट करता है और नए डिस्पैच को रोकता है; कलेक्ट मोड प्रत्येक स्थिति को रिकॉर्ड करता है। कैंसिलेशन नए इंडेक्स दावों को रोकता है और mapper को सिग्नल पास करता है। कार्य O(items) है, परिणाम और स्थिति स्पेस O(items) है, और सक्रिय कार्य O(N) द्वारा सीमित है।
चरण-दर-चरण गहन विश्लेषण
1. परिणाम और एरर कॉन्ट्रैक्ट परिभाषित करें
परिणाम इनपुट क्रम बनाए रखते हैं। कलेक्ट मोड मूल वैल्यू या कारण के साथ fulfilled या rejected स्थिति लौटाता है; undefined सफलता का मार्कर नहीं हो सकता। फेल-फास्ट पहले देखे गए एरर को लौटाता है, साथ ही यह ध्यान में रखते हुए कि JavaScript पहले से शुरू किए गए प्रॉमिस को जबरन समाप्त नहीं कर सकता। एक mapper जो सिग्नल स्वीकार करता है, वह कैंसिलेशन में सहयोग कर सकता है।
2. फिक्स्ड वर्कर्स और इंडेक्स आवंटन का उपयोग करें
अगले इंडेक्स को साझा स्थिति (shared state) में रखें। प्रत्येक वर्कर तब तक लूप करता है जब तक कि इंडेक्स सीमा से बाहर न हो जाए, कैंसिलेशन सेट न हो जाए, या फेल-फास्ट डिस्पैच को रोक न दे। किसी कार्य को शुरू करने से पहले इंडेक्स बढ़ाएं ताकि एक आइटम को केवल एक ही बार क्लेम किया जा सके। निष्क्रिय प्रॉमिस से बचने के लिए min(N, items.length) वर्कर्स का उपयोग करें।
3. सिंक्रोनस थ्रो और पूर्णता क्रम को संभालें
सिंक्रोनस mapper थ्रो को पकड़ें और Promise.resolve के साथ वैल्यू और प्रॉमिस दोनों को सामान्यीकृत (normalize) करें। सफलता या विफलता को मूल इंडेक्स में लिखें; पूर्णता कॉलबैक से कभी भी पुश (push) न करें। जैसे ही एक वर्कर समाप्त होता है, वह अगले इंडेक्स को क्लेम करता है, जिससे सक्रिय कार्य को बढ़ाए बिना थ्रूपुट बना रहता है।
4. कैंसिलेशन प्रोपेगेट करें और डिस्पैच रोकें
यदि सिग्नल पहले से ही एबॉर्ट हो चुका है, तो काम शुरू करने से पहले रिजेक्ट करें या प्रलेखित कैंसिलेशन एरर लौटाएं। चल रहे कार्यों को वही सिग्नल प्राप्त होता है। शेड्यूलर अपने मुख्य प्रॉमिस को सेटल करने से पहले वर्कर्स के बाहर निकलने की प्रतीक्षा करता है, ताकि कॉलर तब पूर्णता न देखें जब बैकग्राउंड लूप डिस्पैच करना जारी रखे हुए हो। कैंसिलेशन और व्यावसायिक एरर्स के कारण स्पष्ट रूप से अलग होने चाहिए।
5. किनारों (edges) और जटिलता को सत्यापित करें
एक खाली ऐरे, N बराबर शून्य, इनपुट से बड़ा N, सिंक्रोनस वैल्यूज और थ्रो, विभिन्न विलंब, पहली विफलता, कई विफलताएं, और बीच में कैंसिलेशन का परीक्षण करें। यह सुनिश्चित करने के लिए कि यह कभी N से अधिक न हो, एक सक्रिय काउंटर का उपयोग करें और यह पुष्टि करने के लिए एक हुक का उपयोग करें कि प्रत्येक इंडेक्स केवल एक बार चलता है। Mapper कॉल्स O(items) हैं, परिणाम स्पेस O(items) है, और शेड्यूलर कंकरेंसी O(N) है।
मजबूत नमूना उत्तर
मैं मान्य करता हूं कि N एक धनात्मक पूर्णांक है, min(N, items.length) वर्कर्स बनाता हूं, और एक नेक्स्ट-इंडेक्स काउंटर साझा करता हूं। एक वर्कर एक इंडेक्स क्लेम करता है, Promise.resolve के माध्यम से mapper को कॉल करता है ताकि सिंक्रोनस वैल्यूज और थ्रो समान पथ का अनुसरण करें, और इंडेक्स के आधार पर परिणाम लिखता है। फेल-फास्ट एक स्टॉप-डिस्पैच फ्लैग सेट करता है और पहले एरर को प्रोपेगेट करता है; कलेक्ट मोड प्रत्येक स्थिति को बनाए रखता है। कैंसिलेशन नए क्लेम को रोकता है और सक्रिय mappers को सिग्नल पास करता है, फिर वर्कर्स के बाहर निकलने की प्रतीक्षा करता है। टेस्ट्स अव्यवस्थित विलंब, सिंक्रोनस एरर्स, खाली इनपुट, N सीमाओं, और कैंसिलेशन को कवर करते हैं, इस दावे के साथ कि सक्रिय कार्य कभी N से अधिक नहीं होता है।
सामान्य गलतियाँ
Promise.all(items.map(mapper))को कॉल करना और सभी कार्यों को एक साथ शुरू करना।- परिणामों को पुश करना जिससे आउटपुट इनपुट क्रम के बजाय पूर्णता क्रम का अनुसरण करता है।
- केवल प्रॉमिस रिजेक्शन को पकड़ना और सिंक्रोनस mapper थ्रो को छोड़ देना।
- फेल-फास्ट के बाद भी डिस्पैच जारी रखना, या यह मान लेना कि रिजेक्ट चल रहे काम को स्वचालित रूप से रद्द कर देता है।
- कैंसिलेशन को एक सामान्य व्यावसायिक एरर की तरह मानना जिससे कॉल करने वाले पुनः प्रयास व्यवहार का चयन नहीं कर पाते।
- N, खाली इनपुट, और साधारण गैर-Promise mapper वैल्यूज के सत्यापन को छोड़ना।
अनुवर्ती प्रश्न और उत्तर
अगले आइटम को पुनरावर्ती (recursively) रूप से क्यों शुरू न करें?
पुनरावृत्ति (Recursion) एक क्रमिक श्रृंखला को व्यक्त कर सकती है, लेकिन इसे कंकरेंसी, एरर्स और कैंसिलेशन को भी बनाए रखना होगा। फिक्स्ड वर्कर्स सक्रिय-कार्य प्रमाण को अधिक स्पष्ट बनाते हैं और गहरी पुनरावृत्ति या डुप्लिकेट डिस्पैच से बचाते हैं।
फेल-फास्ट के दौरान पहले से चल रहे कार्यों का क्या होता है?
JavaScript प्रॉमिस में जबरन समाप्त करने का कोई सामान्य प्रिमिटिव नहीं है। नए डिस्पैच को रोकें और जब mapper AbortSignal के साथ सहयोग करता है तो abort को कॉल करें; अन्यथा कार्यों को बाहरी रूप से तय परिणाम में लिखे बिना समाप्त होने दें।
कलेक्ट मोड को एरर्स का प्रतिनिधित्व कैसे करना चाहिए?
मूल मान या कारण को बनाए रखते हुए fulfilled और rejected में अंतर करने वाला प्रति-आइटम स्थिति ऑब्जेक्ट लौटाएं। एक सेंटिनल असुरक्षित है क्योंकि एक सफल मान स्वयं undefined या null हो सकता है।
आप कंकरेंसी को गतिशील रूप से कैसे समायोजित करेंगे?
सक्रिय कार्य से अलग कॉन्फ़िगर किए गए अधिकतम को ट्रैक करें और सुरक्षित सीमाओं पर क्लेम जोड़ें या रोकें। डायनामिक समायोजन प्रमाण और परीक्षण लागत को बढ़ाता है, इसलिए जब तक आवश्यकता स्पष्ट रूप से अनुकूलन की मांग न करे, तब तक एक निश्चित सीमा का उपयोग करें।