नियंत्रण में गोरोटाइन की मौत

प्रविष्टि

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

लेख अनुवाद

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

यदि आप समुदाय में कई दिनों तक वार्तालाप सुनते हैं, तो एक अच्छा मौका है कि आप किसी को सिद्धांत पर गर्व से सुनेंगे:

साझा मेमोरी का उपयोग करके संवाद न करें, संचार का उपयोग करके मेमोरी साझा करें।

इस विषय पर एक ब्लॉग पोस्ट है , साथ ही एक इंटरैक्टिव कोड वॉक व्यायाम भी है ।

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

अपने लेख में, मैं इस दृष्टिकोण से संबंधित गो में वर्तमान में खुले प्रश्न का उल्लेख करना चाहता हूं: पृष्ठभूमि गतिविधि का पूरा होना ।

एक उदाहरण के रूप में, आइए एक विशेष सरलीकृत गोरोइनटाइन बनाएं जो एक पाइप के माध्यम से तार भेजता है:

 type LineReader struct { Ch chan string r *bufio.Reader } func NewLineReader(r io.Reader) *LineReader { lr := &LineReader{ Ch: make(chan string), r: bufio.NewReader(r), } go lr.loop() return lr } 

LineReader संरचना में एक च चैनल है जिसके माध्यम से ग्राहक लाइनों को प्राप्त कर सकता है, साथ ही एक आंतरिक बफर आर (बाहर से दुर्गम) कुशलता से इन पंक्तियों को पढ़ने के लिए उपयोग किया जाता है। NewLineReader फ़ंक्शन एक आरंभिक LineReader बनाता है, एक पढ़ा चक्र शुरू करता है और बनाई गई संरचना को लौटाता है।

अब आइए स्वयं पाश देखें:

 फंक (एलआर * लाइनराइडर) लूप () {
         {के लिए
                 लाइन, इरेट: = lr.r.ReadSlice ('\ n')
                 अगर गलत है! = nil {
                         पास (lr.Ch)
                         वापसी
                 }
                 lr.Ch <- string (लाइन)
         }
 }

लूप में, हम बफर से लाइन प्राप्त करते हैं, एक त्रुटि के मामले में, चैनल बंद करें और बंद करें, अन्यथा - लाइन को दूसरी तरफ स्थानांतरित करें, संभवतः अवरुद्ध करते हुए यह अपनी बात कर रहा है। यह गो-डेवलपर के लिए सभी स्पष्ट और परिचित है।

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

मैं यह नहीं कह रहा हूं कि यह कुछ ऐसा है जो किसी भी तरह से करना मुश्किल है। मैं कहना चाहता हूं कि आज इन मुद्दों को सरल और सुसंगत तरीके से संभालने के लिए आम तौर पर स्वीकृत दृष्टिकोण नहीं है। या शायद नहीं। समस्या के समाधान की कोशिश में गो के लिए कब्र पैकेज मेरा प्रयोग है।

कार्य मॉडल सरल है: मकबरे पर नज़र रखता है कि क्या गोरोइन जीवित है, मर रहा है या मृत है, साथ ही मृत्यु का कारण भी है।

इस मॉडल को समझने के लिए, आइए देखें कि यह अवधारणा लाइनरेडर उदाहरण पर कैसे लागू होती है। पहले कदम के रूप में, आपको समाधि समर्थन को जोड़ने के लिए निर्माण प्रक्रिया को संशोधित करना होगा:

type LineReader struct {
Ch chan string
r *bufio.Reader
t tomb.Tomb
}
 
func NewLineReader(r io.Reader) *LineReader {
lr := &LineReader{
Ch: make(chan string),
r: bufio.NewReader(r),
}
go lr.loop()
return lr
}

यह बहुत समान दिखता है। संरचना में केवल एक नया क्षेत्र, यहां तक ​​कि निर्माण कार्य भी नहीं बदला है।

अगला, हम त्रुटि ट्रैकिंग और रुकावट का समर्थन करने के लिए लूप फ़ंक्शन को संशोधित करते हैं:

func (lr *LineReader) loop() {
defer lr.t.Done()
for {
line, err := lr.r.ReadSlice('n')
if err != nil {
close(lr.Ch)
lr.t.Kill(err)
return
}
select {
case lr.Ch <- string(line):
case <-lr.t.Dying():
close(lr.Ch)
return
}
}
}

आइए कुछ दिलचस्प बिंदुओं पर ध्यान दें: पहला, लूप फ़ंक्शन के पूरा होने से ठीक पहले, डोर को गोरोइन के पूरा होने को ट्रैक करने के लिए कहा जाता है। फिर, पहले अप्रयुक्त त्रुटि को अब किल विधि में पास किया जाता है, जो मरने के रूप में गोरोइन को चिह्नित करती है। अंत में, चैनल का लिंक बदल दिया गया है ताकि किसी भी कारण से गोरोइन की मृत्यु हो जाने पर उसे ब्लॉक न किया जाए।

टॉम्ब में डाइंग और डेड चैनल हैं, उसी नाम के तरीकों से लौटे हैं, जो उस समय बंद हो जाते हैं जब टॉम्ब उसी के अनुसार अपनी स्थिति बदलता है। ये चैनल आपको राज्य बदलने तक एक स्पष्ट लॉक को व्यवस्थित करने की अनुमति देते हैं, साथ ही ऐसे मामलों में चुनिंदा अभिव्यक्ति को चुनिंदा रूप से अनलॉक करते हैं, जैसा कि ऊपर दिखाया गया है।

इस तरह के एक संशोधित लूप के रूप में ऊपर वर्णित है, बाहर से शुद्ध तुल्यकालिक गोरोइन पूरा करने का अनुरोध करने के लिए स्टॉप विधि को लागू करना आसान है:

func (lr *LineReader) Stop() error {
lr.t.Kill(nil)
return lr.t.Wait()
}

इस स्थिति में, किल विधि कब्र को गोरोइन के बाहर से मरने की स्थिति में डाल देगी, और प्रतीक्षा विधि अवरुद्ध हो जाएगी जब तक कि गोरआउट पूरा नहीं हो जाता और इसे डोन विधि के माध्यम से रिपोर्ट करता है, जैसा कि ऊपर दिखाया गया है। यह प्रक्रिया सही ढंग से व्यवहार करती है, भले ही आंतरिक त्रुटियों के कारण गोरोइन पहले ही मर चुका हो या मरणासन्न स्थिति में था, क्योंकि वास्तविक त्रुटि के साथ किल विधि को पहला कॉल केवल गोरोइन की मृत्यु के कारण के रूप में याद किया जाता है। T.Kill को दिया गया शून्य मान वास्तविक त्रुटि के बिना स्वच्छ समाप्ति के कारण के रूप में उपयोग किया जाता है और गोरोइन के अंत में प्रतीक्षा करने के लिए प्रतीक्षा करता है, जो गो मुहावरों पर एक साफ रोक को इंगित करता है।

यह वास्तव में इस विषय पर कहा जा सकता है। जब मैंने गो 1 पर विकसित करना शुरू किया, तो मैं सोच रहा था कि क्या इस तरह की समस्याओं के लिए एक अच्छे समझौते के लिए भाषा से अधिक समर्थन की आवश्यकता होती है, जैसे कि कुछ प्रकार की गोरोआटाइन की स्थिति को ट्रैक करना, जैसे कि एरलांग अपनी हल्की प्रक्रियाओं के साथ करता है, लेकिन यह पता चला कि यह मौजूदा बिल्डिंग ब्लॉक्स का उपयोग करके कार्य प्रक्रिया को व्यवस्थित करने का मामला है।

कब्र पैकेज और उसका प्रकार मकबरा मौजूदा मुहावरों से प्रेरित, परिचित विधि नामों के साथ, गोरोइन को पूरा करने के लिए एक अच्छी व्यवस्था का एक वास्तविक प्रतिनिधित्व है। यदि आप इसका लाभ उठाना चाहते हैं, तो कमांड का उपयोग करके पैकेज प्राप्त किया जा सकता है:

  $ गो को लॉन्चपैड.net/tomb मिलता है

विस्तृत एपीआई प्रलेखन यहां उपलब्ध है:

gopkgdoc.appspot.com/pkg/launchpad.net/tomb

सौभाग्य है