🤳🏽 🥈 ❕ गोलंग में प्रसंग पैकेज को समझना 🧝🏾 👨🏾‍🚀 👦🏻

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

नीचे अपनी परियोजनाओं में इस पैकेज का उपयोग करने में मदद करने के लिए एक छोटा गाइड है, साथ ही साथ कुछ सर्वोत्तम अभ्यास और नुकसान भी हैं।

(नोट: संदर्भ का उपयोग कई पैकेजों में किया जाता है, उदाहरण के लिए, डॉकर के साथ काम करने में)।

शुरू करने से पहले

संदर्भों का उपयोग करने के लिए, आपको यह समझना चाहिए कि गोरोइन और चैनल क्या हैं। मैं उन्हें संक्षेप में विचार करने का प्रयास करूंगा। यदि आप पहले से ही उनसे परिचित हैं, तो सीधे प्रसंग अनुभाग पर जाएँ।

Gorutina

आधिकारिक दस्तावेज कहता है कि "गोरुटिन निष्पादन की एक हल्की धारा है।" गोरआउट्स थ्रेड्स की तुलना में हल्के होते हैं, इसलिए उन्हें प्रबंधित करना अपेक्षाकृत कम संसाधन गहन होता है।

→ सैंडबॉक्स

package main import "fmt" // ,   Hello func printHello() { fmt.Println("Hello from printHello") } func main() { //   //       go func(){fmt.Println("Hello inline")}() //     go printHello() fmt.Println("Hello from main") }

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

चैनल (चैनल)

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

कहते हैं कि हमारे पास int का एक ch चैनल है। यदि आप चैनल को कुछ भेजना चाहते हैं, तो वाक्य रचना ch <- 1 । आप चैनल से कुछ इस तरह प्राप्त कर सकते हैं: var := <- ch , i.e. चैनल से मान लें और इसे चर चर में सहेजें।

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

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

→ सैंडबॉक्स

 package main import "fmt" //       int   func printHello(ch chan int) { fmt.Println("Hello from printHello") //     ch <- 2 } func main() { //  .       make //       : // ch := make(chan int, 2),       . ch := make(chan int) //  .  ,    . //       go func(){ fmt.Println("Hello inline") //     ch <- 1 }() //     go printHello(ch) fmt.Println("Hello from main") //      //     ,    i := <- ch fmt.Println("Received ",i) //      //    ,      <- ch }

संदर्भ (संदर्भ)

जाने का संदर्भ पैकेज आपको किसी प्रकार के "संदर्भ" में अपने प्रोग्राम में डेटा पास करने की अनुमति देता है। एक टाइमआउट, समय सीमा या चैनल की तरह संदर्भ, एक शटडाउन का संकेत देता है और कॉल लौटाता है।

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

और यहां टाइमआउट या समय सीमा का संदर्भ सही हो सकता है।

प्रसंग निर्माण

संदर्भ पैकेज आपको निम्नलिखित तरीकों से संदर्भ बनाने और इनहेरिट करने की अनुमति देता है:

संदर्भ। बैकग्राउंड () ctx संदर्भ

यह फ़ंक्शन एक खाली संदर्भ देता है। इसका उपयोग केवल एक उच्च स्तर पर (मुख्य या उच्चतम स्तर के अनुरोध हैंडलर में) किया जाना चाहिए। इसका उपयोग अन्य संदर्भों को प्राप्त करने के लिए किया जा सकता है, जिसके बारे में हम बाद में चर्चा करेंगे।

 ctx, cancel := context.Background()

लगभग। ट्रांस।: मूल लेख में एक अशुद्धि है, context.Background का उपयोग करने का सही उदाहरण। context.Background निम्नलिखित होगा:

 ctx := context.Background()

संदर्भ। TODO () ctx संदर्भ

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

 ctx, cancel := context.TODO()

लगभग। ट्रांस।: मूल लेख में एक अशुद्धि है, context.TODO का उपयोग करने का सही उदाहरण। context.TODO निम्नलिखित होगा:

 ctx := context.TODO()

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

यहाँ से :

 var ( background = new(emptyCtx) todo = new(emptyCtx) )

संदर्भ .Value (मूल संदर्भ, कुंजी, वैल इंटरफ़ेस {}) (ctx संदर्भ, रद्द करें रद्द करें)

लगभग। लेन: मूल लेख में एक अशुद्धि है, जो context.WithValue लिए सही हस्ताक्षर context.WithValue इस प्रकार है:

 context.WithValue(parent Context, key, val interface{}) Context

यह फ़ंक्शन एक संदर्भ लेता है और इससे प्राप्त एक संदर्भ देता है जिसमें val key के साथ जुड़ा हुआ है और पूरे संदर्भ ट्री से गुजरता है। यही है, जैसे ही आप एक WithValue संदर्भ बनाते हैं, किसी भी व्युत्पन्न संदर्भ को यह मान प्राप्त होगा।

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

 ctx := context.WithValue(context.Background(), key, "test")

संदर्भ। कैन्सेल (मूल संदर्भ) (ctx संदर्भ), रद्द करें रद्द करें)

यह थोड़ा और दिलचस्प हो जाता है। यह फ़ंक्शन उसके पास गए माता-पिता से एक नया संदर्भ बनाता है। अभिभावक पृष्ठभूमि संदर्भ या फ़ंक्शन के तर्क के रूप में पारित संदर्भ हो सकता है।

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

 ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(2 * time.Second))

लगभग। लेन: मूल लेख में, लेखक ने, जाहिरा तौर पर, context.WithCancel लिए, गलती से। context.WithDeadline साथ एक उदाहरण दिया। context.WithCancel लिए सही उदाहरण। context.WithCancel होगा:

 ctx, cancel := context.WithCancel(context.Background())

संदर्भ .Deadline (मूल संदर्भ, d time.Time) (ctx संदर्भ, रद्द करें रद्द करें)

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

 ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(2 * time.Second))

संदर्भ। टाइमआउट (मूल संदर्भ, टाइमआउट समय। अवधि) (ctx संदर्भ, रद्द करें रद्द करें)

यह फ़ंक्शन संदर्भ के समान है। Deadline। अंतर यह है कि समय की लंबाई का उपयोग इनपुट के रूप में किया जाता है। यह फ़ंक्शन एक व्युत्पन्न संदर्भ देता है जो रद्द किए जाने वाले फ़ंक्शन को कॉल करने या एक समय के बाद रद्द कर दिया जाता है।

 ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(2 * time.Second))

लगभग। लेन: मूल लेख में, लेखक, जाहिरा तौर पर, context.WithTimeout लिए गलती से। समय-समय पर context.WithDeadline साथ एक उदाहरण दिया। context.WithTimeout लिए सही उदाहरण। context.WithTimeout यह होगा:

 ctx, cancel := context.WithTimeout(context.Background(), 2 * time.Second)

अपने कार्यों में संदर्भों का स्वागत और उपयोग

अब जब हम जानते हैं कि संदर्भ (पृष्ठभूमि और TODO) कैसे बनाएं और संदर्भ कैसे उत्पन्न करें (WithValue, WithCancel, Deadline और Timeout), आइए चर्चा करें कि उनका उपयोग कैसे करें।

निम्नलिखित उदाहरण में, आप देख सकते हैं कि संदर्भ लेने वाला फ़ंक्शन गोरोइन को लॉन्च करता है और यह उम्मीद करता है कि वह संदर्भ को वापस कर देगा या रद्द कर देगा। चयनित कथन हमें यह निर्धारित करने में मदद करता है कि पहले क्या होता है और फ़ंक्शन को समाप्त करता है।

चैनल को बंद करने के बाद <-ctx.Done() , केस case <-ctx.Done(): चुना जाता है। जैसे ही ऐसा होता है, फ़ंक्शन को कार्य को बाधित करना चाहिए और वापसी की तैयारी करनी चाहिए। इसका मतलब है कि आपको किसी भी खुले कनेक्शन को बंद करना होगा, संसाधनों को मुक्त करना होगा और फ़ंक्शन से वापस लौटना होगा। ऐसे समय होते हैं जब संसाधनों की रिहाई में देरी हो सकती है, उदाहरण के लिए, सफाई लटकी हुई है। आपको इसे ध्यान में रखना चाहिए।

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

 // ,  -      // ,   -    func sleepRandomContext(ctx context.Context, ch chan bool) { //  (. .:  )    //     // ,    defer func() { fmt.Println("sleepRandomContext complete") ch <- true }() //   sleeptimeChan := make(chan int) //       //     go sleepRandom("sleepRandomContext", sleeptimeChan) //  select        select { case <-ctx.Done(): //   ,    //  ,     -   //    ,    ( ) //    -  , //    ,   //         fmt.Println("Time to return") case sleeptime := <-sleeptimeChan: //   ,       fmt.Println("Slept for ", sleeptime, "ms") } }

उदाहरण

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

main समारोह:

एक रद्द समारोह संदर्भ बनाता है
एक अनियंत्रित समय समाप्त होने के बाद रद्द फ़ंक्शन को कॉल करता है

doWorkContext फ़ंक्शन:

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

sleepRandomContext फंक्शन:

कुछ धीमी गति से कार्य करने के लिए गोरोइन लॉन्च करता है
समाप्त होने के लिए गोरोइन का इंतजार करता है, या
मुख्य फ़ंक्शन द्वारा रद्द किए जाने वाले संदर्भ के लिए प्रतीक्षा की जा रही है, समय समाप्त हो गया है, या अपनी स्वयं की कॉल रद्द करें

sleepRandom समारोह:

यादृच्छिक समय पर सो जाता है

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

सैंडबॉक्स (ऐसा लगता है कि सैंडबॉक्स में मैं जिस यादृच्छिक समय का उपयोग करता हूं वह व्यावहारिक रूप से अपरिवर्तित है। यादृच्छिक कंप्यूटर को देखने के लिए अपने स्थानीय कंप्यूटर पर यह प्रयास करें)

→ जीथब

 package main import ( "context" "fmt" "math/rand" "Time" ) //   func sleepRandom(fromFunction string, ch chan int) { //    defer func() { fmt.Println(fromFunction, "sleepRandom complete") }() //    //   , // «»      seed := time.Now().UnixNano() r := rand.New(rand.NewSource(seed)) randomNumber := r.Intn(100) sleeptime := randomNumber + 100 fmt.Println(fromFunction, "Starting sleep for", sleeptime, "ms") time.Sleep(time.Duration(sleeptime) * time.Millisecond) fmt.Println(fromFunction, "Waking up, slept for ", sleeptime, "ms") //   ,     if ch != nil { ch <- sleeptime } } // ,       // ,   -    func sleepRandomContext(ctx context.Context, ch chan bool) { //  (. .:  )    //     // ,    defer func() { fmt.Println("sleepRandomContext complete") ch <- true }() //   sleeptimeChan := make(chan int) //       //     go sleepRandom("sleepRandomContext", sleeptimeChan) //  select        select { case <-ctx.Done(): //   ,    //  ,    doWorkContext  // doWorkContext  main  cancelFunction //  ,     -   //    ,    ( ) //    -  , //    ,   //         fmt.Println("sleepRandomContext: Time to return") case sleeptime := <-sleeptimeChan: //   ,       fmt.Println("Slept for ", sleeptime, "ms") } } //  ,         //       //   ,      main func doWorkContext(ctx context.Context) { //          - //  150  //  ,   ,   150  ctxWithTimeout, cancelFunction := context.WithTimeout(ctx, time.Duration(150)*time.Millisecond) //         defer func() { fmt.Println("doWorkContext complete") cancelFunction() }() //       //         , //      ,    ch := make(chan bool) go sleepRandomContext(ctxWithTimeout, ch) //  select      select { case <-ctx.Done(): //   ,           //     ,   main   cancelFunction fmt.Println("doWorkContext: Time to return") case <-ch: //   ,       fmt.Println("sleepRandomContext returned") } } func main() { //   background ctx := context.Background() //     ctxWithCancel, cancelFunction := context.WithCancel(ctx) //      //        defer func() { fmt.Println("Main Defer: canceling context") cancelFunction() }() //     - //   ,        go func() { sleepRandom("Main", nil) cancelFunction() fmt.Println("Main Sleep complete. canceling context") }() //   doWorkContext(ctxWithCancel) }

नुकसान

यदि फ़ंक्शन संदर्भ का उपयोग करता है, तो सुनिश्चित करें कि रद्दीकरण सूचनाओं को ठीक से हैंडल किया गया है। उदाहरण के लिए, exec.CommandContext तब तक रीड चैनल को बंद नहीं करता है जब तक कि कमांड प्रक्रिया ( Github ) द्वारा बनाए गए सभी कांटे को पूरा नहीं करता है, यानी कि संदर्भ को रद्द करने से तुरंत फ़ंक्शन से वापस नहीं लौटा जाता है अगर cmd.Wait () से प्रतीक्षा करें। जब तक बाहरी कमांड पूरी प्रसंस्करण के सभी कांटे।

यदि आप अधिकतम रनटाइम के साथ टाइमआउट या समय सीमा का उपयोग करते हैं, तो यह अपेक्षित रूप से काम नहीं कर सकता है। ऐसे मामलों में, समय का उपयोग करके टाइमआउट को लागू करना बेहतर होता है। time.After ।

सर्वोत्तम अभ्यास

संदर्भ। बैकग्राउंड का उपयोग केवल उच्चतम स्तर पर किया जाना चाहिए, सभी व्युत्पन्न संदर्भों की जड़ के रूप में।
संदर्भ। TODO का उपयोग तब किया जाना चाहिए जब आप सुनिश्चित न हों कि क्या उपयोग करना है, या यदि वर्तमान फ़ंक्शन भविष्य में संदर्भ का उपयोग करेगा।
संदर्भ रद्द करने की सिफारिश की जाती है, लेकिन इन कार्यों को स्पष्ट और बाहर निकलने में कुछ समय लग सकता है।
संदर्भ.वायु का उपयोग यथासंभव संयम से किया जाना चाहिए, और वैकल्पिक मापदंडों को पारित करने के लिए उपयोग नहीं किया जाना चाहिए। यह एपीआई को समझ से बाहर कर देता है और त्रुटियों को जन्म दे सकता है। ऐसे मूल्यों को तर्क के रूप में पारित किया जाना चाहिए।
एक संरचना में संदर्भों को संग्रहीत न करें, उन्हें कार्यों में स्पष्ट रूप से पारित करें, अधिमानतः पहले तर्क के रूप में।
एक तर्क के रूप में कभी भी शून्य संदर्भ न दें। यदि संदेह है, तो TODO का उपयोग करें।
Context संरचना में एक रद्द करने की विधि नहीं है, क्योंकि केवल फ़ंक्शन जो संदर्भ को प्रकट करता है, उसे रद्द करना चाहिए।

अनुवादक से

हमारी कंपनी में, हम आंतरिक उपयोग के लिए सर्वर एप्लिकेशन विकसित करते समय संदर्भ पैकेज का सक्रिय रूप से उपयोग करते हैं। लेकिन प्रसंग के अलावा सामान्य कामकाज के लिए ऐसे अनुप्रयोगों के लिए अतिरिक्त तत्वों की आवश्यकता होती है, जैसे:

लॉगिंग
आवेदन समाप्ति, पुनः लोड और लॉगोटेट के लिए सिग्नल प्रोसेसिंग
Pid फ़ाइलों के साथ काम करें
कॉन्फ़िगरेशन फ़ाइलों के साथ काम करें
और अन्य

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

हमारे ब्लॉग पर अन्य लेख भी पढ़ें:

गोलंग में प्रसंग पैकेज को समझना