PHP में Asynchrony को मैनेज करना: Promises से Coroutines तक

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

पेश है स्काईेंग बैकएंड डेवलपर सर्गेई झूक के ब्लॉग के एक लेख का अनुवाद।

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

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

वादा

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

भविष्य के मूल्य के लिए स्थानापन्न।

एक वादा भविष्य के अर्थ के लिए एक प्रतिनिधित्व है, एक समय-स्वतंत्र आवरण जो हम एक अर्थ के चारों ओर लपेटते हैं। यदि मूल्य पहले से ही यहाँ है या नहीं तो हमें इसकी परवाह नहीं है। हम उसी के बारे में सोचते रहते हैं। कल्पना कीजिए कि हमारे पास तीन अतुल्यकालिक HTTP अनुरोध हैं जिन्हें "समानांतर में" निष्पादित किया गया है ताकि वे लगभग एक समय पर पूरा हो सकें। लेकिन हम किसी भी तरह उनके जवाबों का समन्वय और आयोजन करना चाहते हैं। उदाहरण के लिए, हम इन उत्तरों को जल्द से जल्द प्राप्त करना चाहते हैं, लेकिन एक मामूली प्रतिबंध के साथ: दूसरे उत्तर को तब तक न छापें जब तक कि पहला प्राप्त न हो जाए। यहां मेरा मतलब है कि अगर $ वादा 1 पूरा हो गया है, तो हम इसे प्रिंट करते हैं। लेकिन अगर $ वादा 2 पूरा हो गया है, तो हम इसे प्रिंट नहीं करते हैं, क्योंकि $ वादा 1 अभी भी प्रगति पर है। कल्पना करें कि हम तीन प्रतिस्पर्धी अनुरोधों को इस तरह से अनुकूलित करने की कोशिश कर रहे हैं कि अंतिम उपयोगकर्ता के लिए वे एक त्वरित अनुरोध की तरह दिखते हैं।

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

<?php use React\Promise\Promise; function fakeResponse(string $url, callable $callback) { $callback("response for $url"); } function makeRequest(string $url) { return new Promise(function(callable $resolve) use ($url) { fakeResponse($url, $resolve); }); } 

यहाँ मेरे दो कार्य हैं:
fakeResponse (स्ट्रिंग $ url, कॉल करने योग्य $ कॉलबैक) में एक हार्ड-कोडित प्रतिक्रिया होती है और इस उत्तर के साथ निर्दिष्ट कॉलबैक की अनुमति देता है;
makeRequest (string $ url) एक वादा लौटाता है जो यह दर्शाता है कि अनुरोध पूरा हो चुका है।

क्लाइंट कोड से, हम बस मेक रेयरेस्ट () फ़ंक्शन को कॉल करते हैं और वादे प्राप्त करते हैं:

 <?php $promise1 = makeRequest('url1'); $promise2 = makeRequest('url2'); $promise3 = makeRequest('url3'); 

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

 <?php $promise1 ->then('var_dump') ->then(function() use ($promise2) { return $promise2; }) ->then('var_dump') ->then(function () use ($promise3) { return $promise3; }) ->then('var_dump') ->then(function () { echo 'Complete'; }); 

उपरोक्त कोड में, हम $ वादे 1 से शुरू करते हैं। एक बार जब यह पूरा हो जाता है, तो हम इसके मूल्य को प्रिंट करते हैं। हमें परवाह नहीं है कि इसमें कितना समय लगता है: एक सेकंड या एक घंटे से कम। जैसे ही वादा पूरा होगा, हम उसका मूल्य छापेंगे। और फिर हम $ वादे 2 की प्रतीक्षा करते हैं। और यहाँ हमारे दो परिदृश्य हो सकते हैं:

$ वादा 2 पहले ही पूरा हो गया है, और हम तुरंत इसके मूल्य को प्रिंट करते हैं;
$ वादा 2 अभी भी पूरा हो रहा है, और हम इंतजार कर रहे हैं।

वादों की जंजीर की बदौलत हमें अब इस बात की चिंता करने की जरूरत नहीं है कि कुछ वादे पूरे हुए हैं या नहीं। प्रॉमिस समय पर निर्भर नहीं करता है, और इस तरह यह हमारे राज्यों को हमसे छिपाता है (इस प्रक्रिया में, पहले से ही पूरा या रद्द)।

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

जनरेटर

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

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

 <?php use Recoil\React\ReactKernel; // ... ReactKernel::start(function () { $promise1 = makeRequest('url1'); $promise2 = makeRequest('url2'); $promise3 = makeRequest('url3'); var_dump(yield $promise1); var_dump(yield $promise2); var_dump(yield $promise3); }); 

इस कोड के लिए, मैं लाइब्रेरी recoilphp / recoil का उपयोग करता हूं, जो आपको ReactKernel :: start () कहते हैं । रेकोइल, PHPct जनरेटर का उपयोग करके ReactPHP अतुल्यकालिक वादों को निष्पादित करना संभव बनाता है।

यहां, हम अभी भी समानांतर में तीन प्रश्न कर रहे हैं, लेकिन अब हम उपज कीवर्ड का उपयोग करके प्रतिक्रियाओं को हल कर रहे हैं। और फिर, हम प्रत्येक वादे के अंत में परिणाम प्रदर्शित करते हैं, लेकिन केवल पिछले एक के बाद।

Korutiny

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

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

अनुक्रमिक निष्पादन

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

 <?php use Recoil\React\ReactKernel; // ... ReactKernel::start(function () { echo 'Response 1: ', yield makeRequest('url1'), PHP_EOL; echo 'Response 2: ', yield makeRequest('url2'), PHP_EOL; echo 'Response 3: ', yield makeRequest('url3'), PHP_EOL; }); 

वादा 1: यहां प्रदर्शित किया जाएगा, फिर निष्पादन और इंतजार होगा। जैसे ही MakeRequest ('url1') से किया गया वादा पूरा होता है, हम उसका परिणाम प्रिंट कर लेते हैं और कोड की अगली पंक्ति पर चले जाते हैं।

हैंडलिंग में त्रुटि

प्रॉमिस / ए + प्रॉमिस स्टैंडर्ड में कहा गया है कि प्रत्येक प्रॉमिस में तब () और कैच () तरीके होते हैं। यह इंटरफ़ेस आपको वादों से चेन बनाने और वैकल्पिक रूप से त्रुटियों को पकड़ने की अनुमति देता है। निम्नलिखित कोड पर विचार करें:

 <?php operation()->then(function ($result) { return anotherOperation($result); })->then(function ($result) { return yetAnotherOperation($result); })->then(function ($result) { echo $result; }); 

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

 <?php use Recoil\React\ReactKernel; use React\Promise\RejectedPromise; // ... function failedOperation() { return new RejectedPromise(new RuntimeException('Something went wrong')); } ReactKernel::start(function () { try { yield failedOperation(); } catch (Throwable $error) { echo $error->getMessage() . PHP_EOL; } }); 

अतुल्यकालिक कोड पठनीय बनाना

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

 <?php $promise1 ->then('var_dump') ->then(function() use ($promise2) { return $promise2; }) ->then('var_dump') ->then(function () use ($promise3) { return $promise3; }) ->then('var_dump') ->then(function () { echo 'Complete'; }); 

हमें यह समझने के लिए मानसिक रूप से अलग होना होगा कि वहां क्या हो रहा है। इसलिए हमें अतुल्यकालिक नियंत्रण के लिए एक अलग पैटर्न की आवश्यकता है। और संक्षेप में, जनरेटर एसिंक्रोनस कोड लिखने का एक तरीका प्रदान करते हैं ताकि यह तुल्यकालिक जैसा दिखाई दे।

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

यदि हम ReactPHP के बारे में बात कर रहे हैं, तो हम कोरटाइन के रूप में वादे लिखने के लिए RecoilPHP लाइब्रेरी का उपयोग कर सकते हैं। Amp में, बॉक्स के ठीक बाहर कॉरपेट उपलब्ध हैं।