डिज़ाइन पैटर्न सॉफ़्टवेयर डिज़ाइन में उत्पन्न होने वाली सामान्य समस्याओं के लिए आजमाए और परखे हुए समाधान हैं। वे इन समस्याओं को लचीले और पुन: प्रयोज्य तरीके से हल करने के लिए एक टेम्पलेट या मार्गदर्शिका प्रदान करते हैं।

प्रत्येक पैटर्न सर्वोत्तम अभ्यास का प्रतिनिधित्व करता है जिसे डेवलपर्स अपने विशिष्ट संदर्भ के अनुसार अनुकूलित कर सकते हैं। डिज़ाइन पैटर्न को अक्सर तीन मुख्य श्रेणियों में वर्गीकृत किया जाता है।

इस श्रृंखला को शुरू करने के लिए, आइए सिंगलटन पैटर्न के बारे में बात करें।

एकाकी वस्तु

सिंगलटन पैटर्न यह सुनिश्चित करता है कि एक वर्ग के पास केवल एक उदाहरण है और उस उदाहरण तक पहुंच का एक वैश्विक बिंदु प्रदान करता है।

यह उन मामलों में उपयोगी है जहां आपको किसी साझा संसाधन को प्रबंधित करने की आवश्यकता होती है, जैसे डेटाबेस कनेक्शन या कॉन्फ़िगरेशन सेटिंग्स।

समस्या का विवरण

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

एसिंक्रोनस कोड के साथ काम करते समय ऐसा होना बहुत आम है, जहां कई गोरोइन एक वर्ग के नए उदाहरण बना सकते हैं या साझा संसाधनों तक पहुंच सकते हैं।

वास्तविक दुनिया का उदाहरण

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

कार्यान्वयन

package main

import (
    "fmt"
    "sync"
)

type Singleton interface {
    DoSomething() string
}

type singleton struct{}

var lock = &sync.Mutex{}

var instance *singleton

func NewSingletonInstance() *singleton {
    if instance == nil {
        lock.Lock()
        defer lock.Unlock()
        if instance == nil {
            fmt.Println("Creating single instance now.")
            instance = &singleton{}
        } else {
            fmt.Println("Single instance already created.")
        }
    } else {
        fmt.Println("Single instance already created.")
    }

    return instance
}

func (s *singleton) DoSomething() string {
    return "Doing something."
}

func main() {
    instance1 := NewSingletonInstance()
    instance2 := NewSingletonInstance()
    fmt.Printf("%p\n", instance1)
    fmt.Printf("%p\n", instance2)
}

फ़ंक्शन NewSingletonInstance यह सुनिश्चित करता है कि सिंगलटन का केवल एक उदाहरण बनाया जाए, भले ही कई बार कॉल किया जाए।

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