हम सभी जानते हैं कि NodeJs सामान्य जावा सर्वर की तुलना में अधिक अनुरोधों को संभाल सकता है, लेकिन आने वाले अनुरोधों के लिए कोई FIFO प्रकार की संरचना को कैसे बनाए रखता है?

आइए एक फ्लैश सेल कहें, जहां हजारों अनुरोध कम समय में सीमित मात्रा में कुछ खरीदने के लिए बमबारी करते हैं ??

हम कैसे तय करते हैं कि कौन सा अनुरोध पहले उत्पाद प्राप्त करने और उत्पाद की स्थिति को available से sold out (सिर्फ एक उदाहरण) में बदलने के लिए मिलता है?

धन्यवाद

1
Syed Faizan 10 फरवरी 2016, 20:27

1 उत्तर

सबसे बढ़िया उत्तर

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

यदि आप प्रत्येक आने वाले अनुरोध को एक कतार में प्रतीक्षा करते हैं, जब तक कि इससे पहले आने वाले सभी अनुरोध पूरी तरह से नहीं हो जाते (ऐसा कुछ जो किया जा सकता है), तो आप गंभीरता से अपने नोड.जेएस सर्वर की मापनीयता को बर्बाद कर देंगे और अधिकांश समय ऐसा होगा कुछ I/O ऑपरेशन किए जाने की प्रतीक्षा में बेकार बैठे रहें, इसलिए ऐसा लगता है कि यह सही डिज़ाइन नहीं है।

आइए एक फ्लैश सेल कहें, जहां हजारों अनुरोध कम समय में सीमित मात्रा में कुछ खरीदने के लिए बमबारी करते हैं ??

हम यह कैसे तय करते हैं कि कौन सा अनुरोध पहले उत्पाद प्राप्त करने के लिए मिलता है और उत्पाद की स्थिति को उपलब्ध से बिक चुके में बदल देता है (सिर्फ एक उदाहरण)?

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

आपको यह सुनिश्चित करना होगा कि आपका कोड जो साझा संसाधनों (जैसे डेटाबेस) तक पहुंचता है, समवर्ती के लिए सुरक्षित है और साझा डेटा के बारे में कोई परेशानी नहीं करता है।

2
jfriend00 10 फरवरी 2016, 20:54
मैं आपकी बात से सहमत हूं, लेकिन क्या होगा यदि कोई अनुरोध एक एसिंक विधि का आह्वान करता है और इससे पहले कि यह कार्य निष्पादन समाप्त कर सके, 10 अन्य अनुरोधों द्वारा 10 अन्य एसिंक विधियों का आह्वान किया गया है। (मान लें कि केवल 5 उत्पाद शेष हैं) पहला अनुरोध अभी भी डीबी पर उपलब्ध उत्पादों को 5 से 4 तक अपडेट नहीं किया है, इस समय अन्य सभी अनुरोध 5 उपलब्ध उत्पाद देखते हैं, जहां अब केवल 4 हैं (पहला अनुरोध पहला उत्पाद प्राप्त करें)। हम इसे कैसे संभालते हैं? और क्या होता है यदि अनुरोधों की संख्या को 100x से गुणा किया जाता है?
 – 
Syed Faizan
11 फरवरी 2016, 08:18
1
- आप जो वर्णन कर रहे हैं वह समवर्ती अनुरोधों के लिए एक डिज़ाइन चुनौती है। कोई सामान्य समाधान नहीं है। यह बहुत सी चीजों पर निर्भर करता है, जिसमें आप किस प्रकार के साझा डेटा जोड़तोड़ कर रहे हैं और कौन सी व्यवहार संबंधी आवश्यकताएं हैं। विस्तार के किसी भी स्तर पर सहायता शुरू करने के लिए हमें सभी प्रासंगिक कोड देखने होंगे और आपके डेटा और डेटा मॉडल और आपकी व्यावसायिक समस्या/आवेदन को समझना होगा।
 – 
jfriend00
11 फरवरी 2016, 08:42
एक साक्षात्कार के दौरान मुझसे यह प्रश्न पूछा गया था, और उन्होंने पूछा कि इस समस्या को हल करने के लिए आपका दृष्टिकोण क्या है? मुझे इस समस्या का कोई पता नहीं था, लेकिन जवाब जानना चाहता था, Google ने मदद नहीं की (मुझे नहीं पता था कि इस समस्या को क्या कहा जाता है) इसलिए मैंने अभी यहां पोस्ट किया है, मुझे खेद है कि मैंने आपको यह पहले नहीं समझाया, बस सोचा कि यह भविष्य में मदद कर सकता है
 – 
Syed Faizan
11 फरवरी 2016, 13:48
1
- क्या यह आपके सवाल का जवाब है? यदि ऐसा है, तो कृपया उत्तर के बाईं ओर हरे चेकमार्क पर क्लिक करके समुदाय को इंगित करें। यदि नहीं, तो कृपया बताएं कि आपको अभी भी किसकी सहायता की आवश्यकता है।
 – 
jfriend00
3 मार्च 2016, 23:10