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

सिंगलटन क्या है?

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

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

सिंगलटन का उपयोग क्यों करें?

मैं पैटर्न से कार्यान्वयन के बारे में कुछ बिंदुओं को सूचीबद्ध करने जा रहा हूं जो अधिक समझ में आते हैं और यह भी दिखाते हैं कि सब कुछ अच्छा नहीं है, इसके साथ हमें कुछ समस्याएं हो सकती हैं।

फ़ायदे

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

नुकसान

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

सिंगलटन को कार्यान्वित करना

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

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

1 - संरचना को परिभाषित करना

सबसे पहले, हम उस संरचना को परिभाषित करते हैं जिसके लिए हम एक एकल उदाहरण चाहते हैं।

package logger

import (
    "fmt"
    "sync"
)

type Logger struct {}

var loggerInstance *Logger

2 - न्यूइंस्टेंस फ़ंक्शन को कार्यान्वित करना

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

package logger

import (
    "fmt"
    "sync"
)

type Logger struct{}

var logger *Logger
var mtx = &sync.Mutex{}

func NewInstance() *Logger {
    if logger == nil {
        mtx.Lock()
        defer mtx.Unlock()
        if logger == nil {
            fmt.Println("Creating new Logger")
            logger = &Logger{}
        }
    } else {
        fmt.Println("Logger already created")
    }
    return logger
}

3 - लॉग प्रकार लागू करना

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

तो आइए एक विधि बनाएं जो हमारे लॉग को जानकारी प्रकार के साथ दिखाएगी। ऐसा करने के लिए हम एक फ़ंक्शन बनाएंगे जो हमारा लॉग संदेश प्राप्त करेगा और इसे INFO प्रारूप में प्रारूपित करेगा।

package logger

import (
    "fmt"
    "sync"
    "time"
)

const (
    INFO    string = "INFO"
)

type Logger struct{}

var logger *Logger
var mtx = &sync.Mutex{}

func NewInstance() *Logger {
    if logger == nil {
        mtx.Lock()
        defer mtx.Unlock()
        if logger == nil {
            fmt.Println("Creating new logger")
            logger = &Logger{}
        }
    } else {
        fmt.Println("Logger already created")
    }
    return logger
}

func (l *Logger) Info(message string) {
    fmt.Printf("%s - %s: %s\n", time.Now().UTC().Format(time.RFC3339Nano), INFO, message)
}

4 - लॉगर का उपयोग करना

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

package main

import (
    "playground-go/pkg/logger"
)

func main() {
    log := logger.NewInstance()
    log.Info("This is an example of log")
}

जब हम प्रोग्राम चलाते हैं तो यह परिणाम होता है:

Creating new logger
2024-07-03T19:34:57.609599Z - INFO: This is an example of log

अगर हम यह परीक्षण करना चाहते हैं कि क्या न्यूइंस्टेंस वास्तव में गारंटी दे रहा है कि हमारे पास केवल एक ही इंस्टेंस चलेगा, तो हम निम्नलिखित परीक्षण कर सकते हैं।

package main

import (
    "fmt"
    "playground-go/pkg/logger"
)

func main() {
    log := logger.NewInstance()
    log.Info("This is an example of log")

    log2 := logger.NewInstance()
    log2.Info("This is another example of log")

    if log == log2 {
        fmt.Println("same instance")
    } else {
        fmt.Println("different instance")
    }
}

हमारे लॉग बदल गए हैं और अब हम देख सकते हैं कि हमने एक नए उदाहरण के निर्माण को अवरुद्ध कर दिया है:

Creating new logger
2024-07-03T19:45:19.603783Z - INFO: This is an example of log
Logger already created
2024-07-03T19:45:19.603793Z - INFO: This is another example of log
same instance

निष्कर्ष

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

आशा है कि इससे आपको गोलांग में सिंगलटन को बेहतर ढंग से समझने में मदद मिलेगी।