Go में उन्नत स्तर पर डिज़ाइन पैटर्न उदाहरणों के साथ

Go में डिज़ाइन पैटर्न: पेशेवर डेवलपर्स के लिए उन्नत स्तर

Go (Golang) एक ऐसी भाषा है जो कंकरेंसी और माइक्रोसर्विस आर्किटेक्चर के साथ कुशलतापूर्वक काम करने के लिए बनाई गई है। बुनियादी डिज़ाइन पैटर्न जैसे Singleton या Factory अच्छी तरह से ज्ञात हैं, लेकिन उच्च-लोड और दोष-सहिष्णु सिस्टम बनाने के लिए पैटर्न में उन्नत स्तर की महारत की आवश्यकता होती है। इस लेख में, हम चार प्रमुख पैटर्न का विश्लेषण करेंगे: Fan-Out/Fan-In, Pipeline, Worker Pool और Circuit Breaker। उनमें से प्रत्येक स्केलिंग, समानांतर प्रसंस्करण और कैस्केडिंग विफलताओं से सिस्टम की सुरक्षा की व्यावहारिक समस्याओं को हल करता है।

1. Fan-Out / Fan-In पैटर्न: समानांतर डेटा प्रसंस्करण

यह पैटर्न Go में समानांतर कंप्यूटिंग का आधार है। Fan-Out (फैन-आउट) कई गोरूटीन के बीच लोड वितरित करता है, जबकि Fan-In (फैन-इन) परिणामों को वापस एक चैनल में एकत्र करता है।

Fan-Out का कार्यान्वयन

एक कार्य की कल्पना करें: 100 URL को प्रोसेस करना है। अनुक्रमिक प्रसंस्करण के बजाय, हम 10 गोरूटीन चलाते हैं, जिनमें से प्रत्येक एक सामान्य चैनल से कार्य लेता है।

package main\n\nimport (\n    "fmt"\n    "sync"\n)\n\nfunc worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {\n    defer wg.Done()\n    for job := range jobs {\n        // प्रसंस्करण का अनुकरण\n        results <- job * 2\n        fmt.Printf("Worker %d processed job %d\\n", id, job)\n    }\n}\n\nfunc main() {\n    const numJobs = 20\n    const numWorkers = 5\n\n    jobs := make(chan int, numJobs)\n    results := make(chan int, numJobs)\n    var wg sync.WaitGroup\n\n    // Fan-Out: वर्कर्स को लॉन्च करना\n    for w := 1; w <= numWorkers; w++ {\n        wg.Add(1)\n        go worker(w, jobs, results, &wg)\n    }\n\n    // कार्य भेजना\n    for j := 1; j <= numJobs; j++ {\n        jobs <- j\n    }\n    close(jobs)\n\n    // Fan-In: पूरा होने की प्रतीक्षा करना और results को बंद करना\n    go func() {\n        wg.Wait()\n        close(results)\n    }()\n\n    // परिणाम एकत्र करना\n    for result := range results {\n        fmt.Println("Result:", result)\n    }\n}\n

मुख्य बिंदु:

\n
• चैनल jobs Fan-Out बिंदु के रूप में कार्य करता है: सभी वर्कर इससे पढ़ते हैं।
\n
• चैनल results Fan-In बिंदु है: सभी वर्कर इसमें लिखते हैं।
\n
• sync.WaitGroup का उपयोग यह सुनिश्चित करता है कि हम सभी गोरूटीन के पूरा होने के बाद ही results को बंद करें।
\n

2. Pipeline पैटर्न: डेटा का कन्वेयर प्रसंस्करण

Pipeline चरणों की एक श्रृंखला है, जहां प्रत्येक चरण डेटा को प्रोसेस करता है और इसे अगले चरण में भेजता है। Go में, इसे चैनलों के अनुक्रम के माध्यम से कार्यान्वित किया जाता है। यह पैटर्न ETL प्रक्रियाओं, लॉग प्रसंस्करण या डेटा ट्रांसफॉर्मेशन के लिए आदर्श है।

उदाहरण: टेक्स्ट प्रसंस्करण कन्वेयर

package main\n\nimport "fmt"\n\n// चरण 1: संख्याओं का उत्पादन\nfunc generate(nums ...int) <-chan int {\n    out := make(chan int)\n    go func() {\n        for _, n := range nums {\n            out <- n\n        }\n        close(out)\n    }()\n    return out\n}\n\n// चरण 2: वर्ग में बदलना\nfunc square(in <-chan int) <-chan int {\n    out := make(chan int)\n    go func() {\n        for n := range in {\n            out <- n * n\n        }\n        close(out)\n    }()\n    return out\n}\n\n// चरण 3: 2 से गुणा करना\nfunc multiply(in <-chan int, factor int) <-chan int {\n    out := make(chan int)\n    go func() {\n        for n := range in {\n            out <- n * factor\n        }\n        close(out)\n    }()\n    return out\n}\n\nfunc main() {\n    // पाइपलाइन का निर्माण\n    pipeline := multiply(square(generate(1, 2, 3, 4)), 10)\n\n    // परिणामों का उपभोग\n    for result := range pipeline {\n        fmt.Println(result) // 10, 40, 90, 160\n    }\n}\n

लाभ:

\n
• प्रत्येक चरण एक अलग है