Go Academy · पाठ

Backoff और Retry

Backoff के साथ पुनः प्रयास करें

पाठ 4, कुल 4 में से13 चरण

Backoff और Retry, CoddyKit पर Go Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Go Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Go Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

पुनः प्रयास क्यों करें

क्षणिक विफलताएँ, समय-सीमा समाप्त होना, कनेक्शन टूटना और कुछ समय के लिए आने वाली 503 त्रुटियाँ अक्सर दूसरी कोशिश में सफल हो जाती हैं। पुनः प्रयास करने से flaky काम कॉल करने वाले को परेशान किए बिना विश्वसनीय बन जाता है।

भोला पुनः प्रयास खतरनाक है

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

घातीय बैकऑफ़

घातीय बैकऑफ़ प्रत्येक विफलता के बाद प्रतीक्षा को दोगुना करता है: 100ms, 200ms, 400ms, 800ms। इससे नीचे की सेवा को संभलने के लिए समय मिलता है।

delay := 100 * time.Millisecond
for attempt := 0; attempt < 5; attempt++ {
    // try, on failure:
    time.Sleep(delay)
    delay *= 2
}

जिटर जोड़ना

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

jitter := time.Duration(rand.Int63n(int64(delay) / 2))
time.Sleep(delay + jitter)

विलंब की अधिकतम सीमा

घातीय वृद्धि बहुत जल्दी बड़ी हो जाती है। विलंब की अधिकतम सीमा तय करें, ताकि प्रयासों के बीच आपको कई मिनट प्रतीक्षा न करनी पड़े।

if delay > 2*time.Second {
    delay = 2 * time.Second
}

प्रयासों की सीमा

प्रयासों की संख्या हमेशा सीमित रखें। सीमा पूरी होने के बाद अंतिम त्रुटि लौटाएँ, ताकि कॉल करने वाला स्वयं तय कर सके कि आगे क्या करना है और प्रोग्राम हमेशा पुनः प्रयास न करता रहे।

केवल इडेम्पोटेंट कार्य का पुनः प्रयास करें

पुनः प्रयास तभी सुरक्षित है जब किसी काम को दो बार चलाने से कोई नुकसान न हो। GET इडेम्पोटेंट है; कार्ड से शुल्क लेने वाले गैर-इडेम्पोटेंट POST का बिना सोचे पुनः प्रयास नहीं करना चाहिए। आवश्यकता होने पर इडेम्पोटेंसी कुंजियों का उपयोग करें।

पूरा बैकऑफ़ पुनः प्रयास

यह प्रोग्राम ऐसी फ़ंक्शन का पुनः प्रयास करता है जो दो बार विफल होकर तीसरी बार सफल होती है और हर बार विलंब को दोगुना करता है। इसमें केवल मानक लाइब्रेरी का उपयोग किया गया है।

package main

import (
    "errors"
    "fmt"
    "time"
)

func flaky(attempt int) error {
    if attempt < 2 {
        return errors.New("temporary failure")
    }
    return nil
}

func main() {
    delay := 50 * time.Millisecond
    var err error
    for attempt := 0; attempt < 5; attempt++ {
        err = flaky(attempt)
        if err == nil {
            fmt.Println("succeeded on attempt", attempt)
            return
        }
        fmt.Printf("attempt %d failed, waiting %v\n", attempt, delay)
        time.Sleep(delay)
        delay *= 2
    }
    fmt.Println("gave up:", err)
}

context का सम्मान करना

पुनः प्रयास लूप में context भेजें और सोते समय ctx.Done() पर select करें। इससे रद्द किया गया या समय-सीमा पार कर चुका कॉल करने वाला तुरंत पुनः प्रयास रोक सकता है।

select {
case <-ctx.Done():
    return ctx.Err()
case <-time.After(delay):
}

त्रुटियों में अंतर करना

हर त्रुटि पर पुनः प्रयास नहीं किया जा सकता। 400 Bad Request हमेशा विफल होगी। त्रुटि या स्थिति कोड की जाँच करें और केवल समय-सीमा समाप्त होने, 429 और 5xx जैसी क्षणिक श्रेणियों पर पुनः प्रयास करें।

सर्किट ब्रेकर

जब विफलताएँ लगातार बनी रहें, तो सर्किट ब्रेकर प्रत्येक कॉल पर पुनः प्रयास करने के बजाय कुछ समय के लिए अनुरोध भेजना रोक देता है। यह बैकऑफ़ का पूरक है और पूरी तरह बंद निर्भरता की सुरक्षा करता है।

त्वरित जाँच

अपने बैकऑफ़ के ज्ञान का परीक्षण करें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने बैकऑफ़ और पुनः प्रयास सीखा:

घातीय बैकऑफ़ हर विफलता पर विलंब को दोगुना करता है
जिटर एक साथ होने वाले पुनः प्रयासों के तूफ़ान को रोकता है
विलंब की अधिकतम सीमा और प्रयासों की संख्या तय करें
केवल इडेम्पोटेंट कार्य या पुनः प्रयास योग्य त्रुटियों पर पुनः प्रयास करें
रद्दीकरण के लिए context का सम्मान करें

शुरुआत निःशुल्क

एआई शिक्षक के साथ Go सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 51
पाठ: 203

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Backoff और Retry” पाठ निःशुल्क है?

हाँ — Go Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “Backoff और Retry” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Go Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Backoff और Retry” में मैं क्या सीखूँगा?

Backoff के साथ पुनः प्रयास करें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Go Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Go Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Go Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“Backoff और Retry” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Go Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Go Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Go Academy पर वापस जाएँ