एक उदाहरण के रूप में Node.js और PHP का उपयोग करते हुए अतुल्यकालिक और बहुआयामी वास्तुकला में अंतर

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

बहुआयामी मॉडल

यह मॉडल सभी को पता है। हमारा एप्लिकेशन थ्रेड्स (पूल) की एक निश्चित संख्या बनाता है, उनमें से प्रत्येक एक कार्य और प्रसंस्करण के लिए डेटा पारित करता है। कार्य समानांतर में किए जाते हैं। यदि धाराओं में सामान्य डेटा नहीं है, तो हमारे पास सिंक्रनाइज़ेशन के लिए ओवरहेड नहीं होगा, जो काम को काफी तेज करता है। काम पूरा होने के बाद, धागा नहीं मारा जाता है, लेकिन पूल में निहित है, अगले कार्य की प्रतीक्षा कर रहा है। यह थ्रेड्स बनाने और हटाने का ओवरहेड निकालता है। यह इस प्रणाली पर है कि PHP के साथ वेब सर्वर काम करता है। प्रत्येक स्क्रिप्ट अपने स्वयं के धागे में काम करती है। एक धागा एक अनुरोध संसाधित करता है। हमारे पास थ्रेड्स की एक बड़ी संख्या है, धीमी गति से अनुरोध लंबे समय तक स्ट्रीम लेते हैं, फास्ट को लगभग तुरंत संसाधित किया जाता है, दूसरे काम के लिए थ्रेड को मुक्त करता है। यह सभी प्रोसेसर समय लेने के लिए धीमी गति से अनुरोध करने की अनुमति नहीं देता है, जिससे तेज अनुरोध लटका हुआ है। लेकिन ऐसी प्रणाली की कुछ सीमाएं हैं। उदाहरण के लिए, डेटाबेस या फ़ाइल सिस्टम के साथ काम करने पर बड़ी संख्या में धीमी गति से आने वाली स्थिति उत्पन्न हो सकती है। इस तरह के अनुरोध अपने लिए सभी धागे ले जाएंगे, जिससे अन्य अनुरोधों को निष्पादित करना असंभव हो जाएगा। यहां तक ​​कि अगर अनुरोध को निष्पादित करने के लिए केवल 1ms की आवश्यकता है, तो इसे समय पर संसाधित नहीं किया जाएगा। इसे थ्रेड्स की संख्या बढ़ाकर हल किया जा सकता है ताकि वे पर्याप्त संख्या में धीमे अनुरोधों को संभाल सकें। लेकिन दुर्भाग्य से थ्रेड्स ओएस द्वारा संसाधित किए जाते हैं, और प्रोसेसर समय इसे आवंटित किया जाता है। इसलिए, हम जितने अधिक धागे बनाते हैं, उनके प्रसंस्करण के लिए अधिक उपरि लागत और प्रत्येक थ्रेड के लिए कम प्रोसेसर समय आवंटित किया जाता है। स्थिति स्वयं PHP द्वारा बढ़ जाती है - डेटाबेस, फ़ाइल सिस्टम, I / O के साथ काम करने का अवरुद्ध संचालन, उस समय कोई उपयोगी कार्य किए बिना, CPU समय भी व्यतीत करता है। यहां हम ब्लॉकिंग ऑपरेशन की सुविधाओं पर अधिक विस्तार से ध्यान केंद्रित करते हैं। इस स्थिति की कल्पना करें: हमारे पास कई सूत्र हैं। प्रत्येक प्रक्रिया अनुरोध के 1ms से मिलकर अनुरोध करती है, डेटाबेस से डेटा प्राप्त करने और प्राप्त करने के लिए 2ms, और प्राप्त डेटा प्रदान करने के 1ms। कुल में, हम प्रत्येक अनुरोध पर 4ms खर्च करते हैं। डेटाबेस को क्वेरी भेजते समय, थ्रेड प्रतिक्रिया के लिए प्रतीक्षा करना शुरू कर देता है। जब तक डेटा वापस नहीं आएगा, तब तक स्ट्रीम कोई काम नहीं करेगा। यह 4ms में अनुरोध के अनुसार 2ms डाउनटाइम है! हां, हम डेटाबेस से डेटा प्राप्त किए बिना पेज को रेंडर नहीं कर सकते। हमें इंतजार करना चाहिए। लेकिन साथ ही, हमें 50% प्रोसेसर डाउनटाइम मिलता है! और यहां ऊपर से आप प्रत्येक थ्रेड के लिए प्रोसेसर समय के आवंटन पर अतिरिक्त ओएस खर्च फेंक सकते हैं। और जितना अधिक प्रवाह - उतना अधिक खर्च। नतीजतन, हमें काफी बड़ा डाउनटाइम मिलता है। यह समय सीधे डेटाबेस और फाइल सिस्टम के प्रश्नों की अवधि पर निर्भर करता है। सबसे अच्छा समाधान जो हमें उपयोगी कार्य के साथ प्रोसेसर को पूरी तरह से लोड करने की अनुमति देता है, यह एक वास्तुकला का संक्रमण है जो गैर-अवरुद्ध संचालन का उपयोग करता है।

अतुल्यकालिक मॉडल

मल्टी थ्रेडेड की तुलना में कम सामान्य मॉडल, लेकिन कम सुविधाओं के साथ नहीं। एसिंक्रोनस मॉडल एक इवेंट कतार पर बनाया गया है। जब कोई घटना होती है (एक अनुरोध आया, एक फ़ाइल पढ़ी गई, डेटाबेस से एक प्रतिक्रिया आई), इसे कतार के अंत में रखा गया है। इस पंक्ति को संसाधित करने वाला थ्रेड कतार की शुरुआत से एक ईवेंट लेता है, और इस ईवेंट से जुड़े कोड को निष्पादित करता है। जबकि कतार खाली नहीं है, प्रोसेसर काम में व्यस्त होगा। इस योजना के अनुसार, Node.js. हमारे पास एक एकल थ्रेड है जो ईवेंट कतार (क्लस्टर मॉड्यूल के साथ - एक से अधिक थ्रेड होगा) को संसाधित करता है। लगभग सभी ऑपरेशन गैर-अवरुद्ध हैं। ब्लॉकर्स भी उपलब्ध हैं, लेकिन उनका उपयोग अत्यधिक हतोत्साहित किया जाता है। आगे आप समझेंगे क्यों। अनुरोध 1 + 2 + 1ms के साथ एक ही उदाहरण लेते हैं: अनुरोध के आगमन से जुड़ी घटना संदेश कतार से ली गई है। हम अनुरोध को संसाधित करते हैं, 1ms खर्च करते हैं। इसके बाद, डेटाबेस के लिए एक अतुल्यकालिक गैर-अवरोधक क्वेरी बनाई जाती है और नियंत्रण तुरंत पारित हो जाता है। हम कतार से अगली घटना ले सकते हैं और इसे निष्पादित कर सकते हैं। उदाहरण के लिए, हम 1 और अनुरोध करेंगे, प्रसंस्करण को पूरा करेंगे, डेटाबेस को एक अनुरोध भेजेंगे, नियंत्रण वापस करेंगे और एक ही बार करेंगे। और यहाँ डेटाबेस की प्रतिक्रिया बहुत पहले अनुरोध पर आती है। इससे जुड़ी घटना कतारबद्ध है। यदि कतार में कुछ भी नहीं था, तो इसे तुरंत निष्पादित किया जाएगा, डेटा प्रदान किया जाएगा और ग्राहक को वापस दिया जाएगा। यदि कतार में कुछ है, तो आपको अन्य घटनाओं के प्रसंस्करण के लिए इंतजार करना होगा। आमतौर पर, एक एकल अनुरोध की प्रसंस्करण गति बहु-थ्रेडेड सिस्टम और अवरुद्ध संचालन की प्रसंस्करण गति के लिए तुलनीय होगी। सबसे खराब स्थिति में, अन्य घटनाओं के संसाधित होने की प्रतीक्षा करने में समय लगता है, और अनुरोध को अधिक धीरे-धीरे संसाधित किया जाएगा। लेकिन उस समय, जबकि ब्लॉकिंग ऑपरेशन वाली प्रणाली सिर्फ 2ms प्रतिक्रिया का इंतजार करेगी, गैर-अवरुद्ध संचालन वाली प्रणाली 2 अन्य अनुरोधों के 2 और हिस्सों को पूरा करने में कामयाब रही! प्रत्येक अनुरोध कुल मिलाकर थोड़ा धीमा चल सकता है, लेकिन समय की प्रति यूनिट हम बहुत अधिक अनुरोधों को संसाधित कर सकते हैं। कुल मिलाकर प्रदर्शन अधिक रहेगा। प्रोसेसर हमेशा उपयोगी काम में व्यस्त रहेगा। इसी समय, बहु-थ्रेडेड सिस्टम में थ्रेड्स के बीच स्विच करने की तुलना में कतार से प्रक्रिया करने और ईवेंट से स्थानांतरित होने में बहुत कम समय लगता है। इसलिए, गैर-अवरुद्ध संचालन वाले अतुल्यकालिक सिस्टम में सिस्टम में कोर की संख्या से अधिक थ्रेड नहीं होना चाहिए। Node.js ने शुरू में आम तौर पर केवल एकल-थ्रेडेड मोड में काम किया था, और प्रोसेसर के पूर्ण उपयोग के लिए सर्वर की कई प्रतियों को मैन्युअल रूप से उठाना और उनके बीच लोड वितरित करना आवश्यक था, उदाहरण के लिए, nginx का उपयोग करना। अब क्लस्टर मॉड्यूल कई कोर के साथ काम करने के लिए दिखाई दिया है (लेखन के समय, यह अभी भी प्रायोगिक स्थिति है)। यह वह जगह है जहाँ दो प्रणालियों के बीच महत्वपूर्ण अंतर स्पष्ट हो जाता है। अवरोधक संचालन के साथ एक बहु-थ्रेडेड सिस्टम में लंबे समय तक डाउन होता है। थ्रेड्स की अत्यधिक संख्या बहुत अधिक ओवरहेड बना सकती है, जबकि एक अपर्याप्त संख्या में मंदी हो सकती है जब बहुत धीमे अनुरोध होते हैं। गैर-अवरुद्ध संचालन के साथ एक अतुल्यकालिक अनुप्रयोग प्रोसेसर समय का अधिक कुशलता से उपयोग करता है, लेकिन डिजाइन में अधिक कठिन है। यह विशेष रूप से मेमोरी लीक को प्रभावित करता है - Node.js प्रक्रिया बहुत बड़ी मात्रा में समय के लिए काम कर सकती है, और यदि प्रोग्रामर प्रत्येक अनुरोध को संसाधित करने के बाद डेटा को साफ़ करने का ध्यान नहीं रखता है, तो हमें एक रिसाव प्राप्त होगा, जिससे धीरे-धीरे सर्वर को पुनरारंभ करने की आवश्यकता होगी। अवरुद्ध कार्यों के साथ एक अतुल्यकालिक वास्तुकला भी है, लेकिन यह बहुत कम लाभदायक है, जिसे बाद में कुछ उदाहरणों के साथ देखा जा सकता है। हम उन सुविधाओं को उजागर करते हैं जिन्हें अतुल्यकालिक अनुप्रयोगों को विकसित करते समय ध्यान में रखा जाना चाहिए और कुछ त्रुटियों का विश्लेषण करना चाहिए जो लोग अतुल्यकालिक वास्तुकला की सुविधाओं से निपटने की कोशिश करते समय अनुभव करते हैं।

ब्लॉकिंग ऑपरेशन का उपयोग न करें। कभी नहीं

ठीक है, कम से कम जब तक आप पूरी तरह से Node.js की वास्तुकला को नहीं समझते हैं और अवरुद्ध संचालन के साथ सटीक रूप से काम नहीं कर सकते हैं।
जब PHP से Node.js पर स्विच किया जाता है, तो कुछ लोग पहले की तरह उसी शैली में कोड लिखना चाह सकते हैं। दरअसल, अगर हमें फ़ाइल को पहले पढ़ना है, और उसके बाद ही इसकी प्रोसेसिंग करनी है, तो हम निम्नलिखित कोड क्यों नहीं लिख सकते हैं:

var fs = require('fs');
var data = fs.readFileSync("img.png");
response.write(data);

, . , , Node.js , . . , , . :

var fs = require('fs');
fs.readFile("img.png", function(err, data){
	response.write(data);
});

: , , Node.js . — , readFile . , , — . , : , . , . , .
, event-loop:

var fs = require('fs');
var dataModified = false;
var myData;

fs.readFile("file.txt", function(err, data){
	dataModified = true;
	myData = data+" last read "+new Date();
});

while (true){
	if(dataModified)
		break;
}

response.write(myData);

, . , , . - … !

var fs = require('fs');
var events = require('events');
var myData;
var eventEmitter = new events.EventEmitter();

fs.readFile("file.txt", function(err, data){
	myData = data+" last read "+new Date();
	eventEmitter.emit('dataModified', myData);
});

eventEmitter.on('dataModified', function(data){
	response.write(data);
});

-, . — , , emit , . events.EventEmitter . eventEmitter.on , .
, Node.js. , . , .

.

, ? , ? — . , . , . , , , .

function incredibleGigantCycle(){
	cycleProcess();
	process.nextTick(incredibleGigantCycle);
}

. .

,

( Node.js — ). (, 500) , . - ? , . , , , . , . , , .

,

, , . Node.js Sync. callback. , , .

var fs = require('fs');
fs.readFile("img.png", function(err, data){

});
response.write(data);

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

, «-» Node.js, callback', PHP ? .
:

 $user->getCountry()->getCurrency()->getCode()

user.getCountry(function(country){
	country.getCurrency(function(currency){
		console.log(currency.getCode())
	})
})

3 . : PHP . , . , . , - , . — , , , . 3 . PHP , Node.js , , .

Node.js , PHP , . Node.js , . — Node.js. , PHP — Node.js , .