सिंक/Async प्रोग्रामिंग

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

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

OS सिंक्रोनस I/O का उदाहरण:
1. प्रोग्राम CPU को डिस्क से एक फ़ाइल पढ़ने के लिए कहता है।
2. प्रोग्राम का मेन थ्रेड CPU से अलग हो जाता है।
3. पूरा पढ़ें, और कार्यक्रम फिर से क्रियान्वित करना शुरू कर देता है।

// A simple Js example
// Program starts
// Programs uses CPU to execute work.

SampleFunction();
// Program reads from the disk
// Program can't do anything until file loads
readfile("SyncExample.dat")

// Program resumes

विशेष रूप से NodeJs के बिंदु से बात करते हुए, यह Linux में epoll का उपयोग करता है, और विंडोज़ के मामले में, यह एक पूर्णतावादी स्टैक का उपयोग करता है। एक और चीज जो नोडजे करता है वह एक नया थ्रेड स्पिन करता है जो ब्लॉकिंग ऑपरेशन करने की आवश्यकता होने पर ब्लॉक करता है। डिफ़ॉल्ट रूप से, Nodejs के पास libuv लाइब्रेरी में 4 वर्कर थ्रेड हैं , जिनका उपयोग यह I/O संचालन के लिए करता है, लेकिन यह कॉन्फ़िगर करने योग्य है।

OS एसिंक्रोनस कॉल (NodeJS) का उदाहरण
a) प्रोग्राम एक सेकेंडरी थ्रेड को स्पिन करता है
b) सेकेंडरी थ्रेड डिस्क से पढ़ता है। जाहिर है, ओएस वर्तमान प्रोसेसर से हटा देता है
सी) मुख्य कार्यक्रम अभी भी चलता है और निष्पादित करता है।
d) थ्रेड फ़िनिश करता है और मुख्य थ्रेड को कॉल करता है।

// A simple Javascript example
// Program starts
// Programs uses CPU to execute work.

SampleFunction();
// Program reads from the disk
// Program hapilly moves on to the samplefunction2
readfile("SyncExample.dat", onReadFinish(console.log))
//file is not probably read yet

SampleFunction2();
//onReadFinish function called
// executing it

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

अतुल्यकालिक बैकएंड प्रोसेसिंग

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

अतुल्यकालिक कार्यभार का एक वास्तविक दुनिया का उदाहरण:
a) अतुल्यकालिक Postgres ↗ में करता है ।
बी) लिनक्स में एसिंक्रोनस I/O (आईओ-यूरिंग)।
c) एसिंक्रोनस I/O fsync (fs-cache): जब भी हम किसी फाइल में कुछ लिखते हैं, तो यह सीधे डिस्क पर नहीं बल्कि फाइल सिस्टम कैश में लिखा जाता है। ऑपरेटिंग सिस्टम में एक कैश होता है, और राइट्स पेजों में जाते हैं। और फिर, ऑपरेटिंग सिस्टम एक ही बार में सभी पेजों को फ्लश कर देता है।

हम पूरी बात को इस प्रकार सारांशित कर सकते हैं:
ए) सिंक्रोनस प्रोग्रामिंग दृष्टिकोण कार्यों को क्रमिक रूप से निष्पादित करता है। किसी भी पिछले कार्य के समाप्त होने की प्रतीक्षा करने के बाद प्रत्येक कार्य को पूरा किया जाता है।
b) जब कोई कार्य अतुल्यकालिक प्रोग्रामिंग मॉडल में चलाया जाता है, तो हम पिछले एक के समाप्त होने की प्रतीक्षा किए बिना दूसरे पर जा सकते हैं।

पढ़ने के लिए धन्यवाद; मुझे उम्मीद है कि यह मददगार था। किसी और संदेह के मामले में, लिंक्डइन / इंस्टाग्राम
पर बेझिझक कनेक्ट करें ।