జావా సింగిల్టన్ క్లాస్

హాయ్! ఈ రోజు మనం జావా సింగిల్టన్ నమూనాతో ప్రారంభించి, వివిధ డిజైన్ నమూనాల వివరాలలోకి ప్రవేశిస్తాము. సమీక్షిద్దాం: సాధారణంగా డిజైన్ నమూనాల గురించి మనకు ఏమి తెలుసు? డిజైన్ నమూనాలు అనేక తెలిసిన సమస్యలను పరిష్కరించడానికి మేము వర్తించే ఉత్తమ అభ్యాసాలు. డిజైన్ నమూనాలు సాధారణంగా ఏ ప్రోగ్రామింగ్ భాషతో ముడిపడి ఉండవు. పొరపాట్లను నివారించడానికి మరియు చక్రాన్ని మళ్లీ ఆవిష్కరించకుండా ఉండటానికి మీకు సహాయపడే సిఫార్సుల సమితిగా వాటిని ఆలోచించండి.

జావాలో సింగిల్టన్ అంటే ఏమిటి?

సింగిల్టన్ సరళమైన తరగతి-స్థాయి డిజైన్ నమూనాలలో ఒకటి. కొన్నిసార్లు వ్యక్తులు "ఈ క్లాస్ సింగిల్‌టన్" అని అంటారు, అంటే తరగతి సింగిల్‌టన్ డిజైన్ నమూనాను అమలు చేస్తుంది. కొన్నిసార్లు ఒక తరగతిని వ్రాయడం అవసరం, ఇక్కడ మేము ఒకే వస్తువుకు ఇన్‌స్టాంటియేషన్‌ను పరిమితం చేస్తాము. ఉదాహరణకు, లాగింగ్ లేదా కనెక్ట్ చేయడానికి బాధ్యత వహించే తరగతి డేటాబేస్. సింగిల్‌టన్ డిజైన్ నమూనా మనం దీన్ని ఎలా సాధించవచ్చో వివరిస్తుంది. సింగిల్‌టన్ అనేది రెండు పనులను చేసే డిజైన్ నమూనా:

1. తరగతికి సంబంధించిన ఒక ఉదాహరణ మాత్రమే ఉంటుందని ఇది హామీ ఇస్తుంది.

2. ఇది ఆ ఉదాహరణకి గ్లోబల్ యాక్సెస్ యొక్క ఒకే పాయింట్‌ను అందిస్తుంది.

అందువల్ల, సింగిల్టన్ నమూనా యొక్క దాదాపు ప్రతి అమలులో రెండు లక్షణాలు ఉన్నాయి:

1. ఒక ప్రైవేట్ కన్స్ట్రక్టర్. ఇది తరగతి వెలుపల తరగతి వస్తువులను సృష్టించే సామర్థ్యాన్ని పరిమితం చేస్తుంది.

2. తరగతి యొక్క ఉదాహరణను అందించే పబ్లిక్ స్టాటిక్ పద్ధతి. ఈ పద్ధతిని getInstance అంటారు . ఇది తరగతి ఉదాహరణకి గ్లోబల్ యాక్సెస్ యొక్క పాయింట్.

అమలు ఎంపికలు

సింగిల్టన్ డిజైన్ నమూనా వివిధ మార్గాల్లో వర్తించబడుతుంది. ప్రతి ఎంపిక దాని స్వంత మార్గంలో మంచి మరియు చెడు. ఎప్పటిలాగే, ఇక్కడ సరైన ఎంపిక లేదు, కానీ మనం ఒకదాని కోసం ప్రయత్నించాలి. అన్నింటిలో మొదటిది, ఏది మంచి మరియు చెడు అని నిర్ణయించండి మరియు డిజైన్ నమూనా యొక్క వివిధ అమలులను మనం అంచనా వేసే విధానాన్ని ఏ కొలమానాలు ప్రభావితం చేస్తాయి. మంచితో ప్రారంభిద్దాం. అమలును మరింత జ్యుసిగా మరియు ఆకర్షణీయంగా చేసే అంశాలు ఇక్కడ ఉన్నాయి:

• సోమరితనం ప్రారంభించడం: అవసరమైనంత వరకు ఉదాహరణ సృష్టించబడదు.

• సాధారణ మరియు పారదర్శక కోడ్: ఈ మెట్రిక్, వాస్తవానికి, ఆత్మాశ్రయమైనది, కానీ ఇది ముఖ్యమైనది.

• థ్రెడ్ భద్రత: బహుళ-థ్రెడ్ వాతావరణంలో సరైన ఆపరేషన్.

• బహుళ-థ్రెడ్ వాతావరణంలో అధిక పనితీరు: వనరును భాగస్వామ్యం చేసేటప్పుడు తక్కువ లేదా థ్రెడ్ నిరోధించబడదు.

ఇప్పుడు ప్రతికూలతలు. అమలును చెడు వెలుగులోకి తెచ్చే అంశాలను మేము జాబితా చేస్తాము:

• సోమరితనం ప్రారంభించడం లేదు: అప్లికేషన్ ప్రారంభించినప్పుడు తరగతి లోడ్ అయినప్పుడు, అది అవసరమా లేదా అనే దానితో సంబంధం లేకుండా (విరుద్ధంగా, IT ప్రపంచంలో సోమరితనంగా ఉండటం మంచిది)

• క్లిష్టమైన మరియు చదవడానికి కష్టంగా ఉండే కోడ్. ఈ మెట్రిక్ కూడా ఆత్మాశ్రయమైనది. మీ కళ్ళు రక్తస్రావం ప్రారంభిస్తే, మేము అమలు చేయడం ఉత్తమం కాదని మేము అనుకుంటాము.

• థ్రెడ్ భద్రత లేకపోవడం. మరో మాటలో చెప్పాలంటే, "థ్రెడ్ ప్రమాదం". బహుళ-థ్రెడ్ వాతావరణంలో తప్పు ఆపరేషన్.

• బహుళ-థ్రెడ్ వాతావరణంలో పేలవమైన పనితీరు: థ్రెడ్‌లు అన్ని సమయాలలో లేదా తరచుగా వనరును పంచుకునేటప్పుడు ఒకదానికొకటి అడ్డుకుంటాయి.

కోడ్

ఇప్పుడు మేము వివిధ అమలు ఎంపికలను పరిగణించడానికి సిద్ధంగా ఉన్నాము మరియు లాభాలు మరియు నష్టాలను సూచించాము:

సరళమైనది

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {
    }
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

సరళమైన అమలు. ప్రోస్:

• సాధారణ మరియు పారదర్శక కోడ్

• థ్రెడ్ భద్రత

• బహుళ-థ్రెడ్ వాతావరణంలో అధిక పనితీరు

ప్రతికూలతలు:

• సోమరితనం ప్రారంభించడం లేదు.

మునుపటి లోపాన్ని పరిష్కరించే ప్రయత్నంలో, మేము అమలు సంఖ్య రెండు పొందుతాము:

సోమరితనం ప్రారంభించడం

public class Singleton {
  private static final Singleton INSTANCE;

  private Singleton() {}

  public static Singleton getInstance() {
    if (INSTANCE == null) {
      INSTANCE = new Singleton();
    }
    return INSTANCE;
  }
}

ప్రోస్:

• సోమరితనం ప్రారంభించడం.

ప్రతికూలతలు:

• థ్రెడ్ సురక్షితం కాదు

ఈ అమలు ఆసక్తికరంగా ఉంది. మేము బద్ధకంగా ప్రారంభించవచ్చు, కానీ మేము థ్రెడ్ భద్రతను కోల్పోయాము. చింతించకండి - మేము అమలు సంఖ్య మూడులో ప్రతిదీ సమకాలీకరించాము.

సమకాలీకరించబడిన యాక్సెస్

public class Singleton {
  private static final Singleton INSTANCE;

  private Singleton() {
  }

  public static synchronized Singleton getInstance() {
    if (INSTANCE == null) {
      INSTANCE = new Singleton();
    }
    return INSTANCE;
  }
}

ప్రోస్:

• సోమరితనం ప్రారంభించడం.

• థ్రెడ్ భద్రత

ప్రతికూలతలు:

• పేలవమైన మల్టీథ్రెడ్ పనితీరు

అద్భుతమైన! అమలు సంఖ్య మూడులో, మేము థ్రెడ్ భద్రతను పునరుద్ధరిస్తాము! వాస్తవానికి, ఇది నెమ్మదిగా ఉంది... ఇప్పుడు getInstance పద్ధతి సమకాలీకరించబడింది, కాబట్టి ఇది ఒకేసారి ఒక థ్రెడ్ ద్వారా మాత్రమే అమలు చేయబడుతుంది. మొత్తం పద్ధతిని సమకాలీకరించడానికి బదులుగా, మేము వాస్తవానికి కొత్త ఉదాహరణను ప్రారంభించే భాగాన్ని మాత్రమే సమకాలీకరించాలి. కానీ కొత్త ఉదాహరణను సృష్టించడానికి బాధ్యత వహించే భాగాన్ని చుట్టడానికి మేము సింక్రొనైజ్ చేసిన బ్లాక్‌ని ఉపయోగించలేము . అలా చేయడం వల్ల థ్రెడ్ భద్రత ఉండదు. ఇది కొంచెం క్లిష్టంగా ఉంటుంది. సరైన సమకాలీకరణ క్రింద చూడవచ్చు:

రెండుసార్లు తనిఖీ చేసిన లాకింగ్

public class Singleton {
    private static final Singleton INSTANCE;

  private Singleton() {
  }

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

ప్రోస్:

• సోమరితనం ప్రారంభించడం.

• థ్రెడ్ భద్రత

• బహుళ-థ్రెడ్ వాతావరణంలో అధిక పనితీరు

ప్రతికూలతలు:

• 1.5 దిగువన ఉన్న జావా యొక్క మునుపటి సంస్కరణల్లో మద్దతు లేదు (అస్థిర కీవర్డ్ వినియోగం 1.5 వెర్షన్ నుండి పరిష్కరించబడింది)

ఈ అమలు ఎంపిక సరిగ్గా పని చేయడానికి, రెండు షరతుల్లో ఒకదానిని తప్పనిసరిగా సంతృప్తిపరచాలని గుర్తుంచుకోండి. INSTANCE వేరియబుల్ తప్పనిసరిగా తుది లేదా అస్థిరంగా ఉండాలి . ఈ రోజు మనం చర్చించే చివరి అమలు క్లాస్ హోల్డర్ సింగిల్టన్ .

క్లాస్ హోల్డర్

public class Singleton {

   private Singleton() {
   }

   private static class SingletonHolder {
       public static final Singleton HOLDER_INSTANCE = new Singleton();
   }

   public static Singleton getInstance() {
       return SingletonHolder.HOLDER_INSTANCE;
   }
}

ప్రోస్:

• సోమరితనం ప్రారంభించడం.

• థ్రెడ్ భద్రత.

• బహుళ-థ్రెడ్ వాతావరణంలో అధిక పనితీరు.

ప్రతికూలతలు:

• సరైన ఆపరేషన్‌కు సింగిల్టన్ ఆబ్జెక్ట్ లోపాలు లేకుండా ప్రారంభించబడిందని హామీ అవసరం . లేకపోతే, getInstance పద్ధతికి చేసే మొదటి కాల్ ExceptionInInitializerError కి దారి తీస్తుంది మరియు అన్ని తదుపరి కాల్‌లు NoClassDefFoundErrorని ఉత్పత్తి చేస్తాయి .

ఈ అమలు దాదాపు ఖచ్చితమైనది. ఇది సోమరితనం, మరియు థ్రెడ్ సురక్షితమైనది మరియు వేగవంతమైనది. కానీ ఇది ప్రతికూలతల జాబితాలో వివరించినట్లుగా, స్వల్పభేదాన్ని కలిగి ఉంది. సింగిల్టన్ నమూనా యొక్క వివిధ అమలుల పోలిక:

సింగిల్టన్ నమూనా యొక్క లాభాలు మరియు నష్టాలు

సాధారణంగా, సింగిల్టన్ దాని నుండి ఆశించిన దానినే ఖచ్చితంగా చేస్తుంది:

1. తరగతికి సంబంధించిన ఒక ఉదాహరణ మాత్రమే ఉంటుందని ఇది హామీ ఇస్తుంది.

2. ఇది ఆ ఉదాహరణకి గ్లోబల్ యాక్సెస్ యొక్క ఒకే పాయింట్‌ను అందిస్తుంది.

అయితే, ఈ నమూనా లోపాలను కలిగి ఉంది:

1. సింగిల్టన్ ఒకే బాధ్యత సూత్రాన్ని ఉల్లంఘిస్తుంది: దాని ప్రత్యక్ష విధులతో పాటు, సింగిల్‌టన్ క్లాస్ సందర్భాల సంఖ్యను కూడా నియంత్రిస్తుంది.

2. ఒక సాధారణ తరగతి సింగిల్‌టన్‌పై ఆధారపడటం తరగతి పబ్లిక్ కాంట్రాక్ట్‌లో కనిపించదు.

3. గ్లోబల్ వేరియబుల్స్ చెడ్డవి. అంతిమంగా, సింగిల్‌టన్ భారీ గ్లోబల్ వేరియబుల్‌గా మారుతుంది.

4. సింగిల్‌టన్ యొక్క ఉనికి మొత్తం అప్లికేషన్ యొక్క టెస్టబిలిటీని మరియు ప్రత్యేకంగా సింగిల్‌టన్‌ని ఉపయోగించే తరగతులను తగ్గిస్తుంది.

అంతే! :) మేము మీతో జావా సింగిల్టన్ క్లాస్‌ని అన్వేషించాము. ఇప్పుడు, మీ జీవితాంతం, మీ ప్రోగ్రామర్ స్నేహితులతో సంభాషించేటప్పుడు, మీరు నమూనా ఎంత మంచిదో మాత్రమే కాకుండా, దానిని చెడుగా చేసే దాని గురించి కొన్ని పదాలను కూడా పేర్కొనవచ్చు. ఈ కొత్త జ్ఞానాన్ని నేర్చుకోవడం అదృష్టం.

అదనపు పఠనం:

• జావాలో నమూనాలు మరియు సింగిల్టన్
• ఇనిషియలైజేషన్-ఆన్-డిమాండ్ హోల్డర్ ఇడియమ్
• సింగిల్టన్ డిజైన్ నమూనాను అమలు చేయడానికి మరియు ఉపయోగించడానికి ప్రభావవంతమైన మార్గాలు