జావాలో సింగిల్టన్ క్లాస్ - సింగిల్టన్ క్లాస్ ఎలా ఉపయోగించాలి?

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

ఈ వ్యాసంలో నేను కవర్ చేయబోయే విషయాలు క్రింద ఉన్నాయి:

• జావాలో సింగిల్టన్ క్లాస్ అంటే ఏమిటి?
• జావా సింగిల్టన్ క్లాస్ రూపకల్పనకు మార్గాలు
  1. ఆసక్తిగల ప్రారంభ విధానం
  2. లేజీ ప్రారంభ విధానం
  3. థ్రెడ్ సేఫ్ సింగిల్టన్ విధానం
  4. డబుల్ లాక్ పద్ధతిలో లేజీ ప్రారంభించడం
  5. లేజీ లోడ్ విధానం
  6. స్టాటిక్ బ్లాక్ ప్రారంభ విధానం

ప్రారంభిద్దాం.

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

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

అయితే మనకు మొదటి స్థానంలో సింగిల్టన్ క్లాస్ ఎందుకు అవసరం?

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

జావాలోని సింగిల్టన్ క్లాస్ భావనతో మీరు స్పష్టంగా ఉన్నారని నేను నమ్ముతున్నాను. కాబట్టి, ఇప్పుడు దీనిలో మరింత ముందుకు సాగండిజావా వ్యాసంలో సింగిల్టన్ క్లాస్ మరియు అవి ఎలా సృష్టించబడుతున్నాయో చూడండి.

జావా సింగిల్టన్ క్లాస్ రూపకల్పనకు మార్గాలు

జావాలో క్లాస్ సింగిల్టన్ చేయడానికి, మీకు ఈ క్రింది మూడు విషయాలు అవసరం:

1. తరగతి యొక్క స్థిర సభ్యుడు
2. ప్రైవేట్ కన్స్ట్రక్టర్
3. స్టాటిక్ ఫ్యాక్టరీ పద్ధతి

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

1. ఆసక్తిగల ప్రారంభ విధానం
2. లేజీ ప్రారంభ విధానం
3. థ్రెడ్ సేఫ్ సింగిల్టన్ విధానం
4. డబుల్ లాక్ పద్ధతిలో లేజీ ప్రారంభించడం
5. లేజీ లోడ్ విధానం
6. స్టాటిక్ బ్లాక్ ప్రారంభ విధానం

ఇప్పుడు ఈ విధానాలలో ఒక్కొక్కటిగా లోతుగా డైవ్ చేద్దాం.

1. ఆసక్తిగల ప్రారంభ విధానం

సింగిల్టన్ తరగతిని సృష్టించడానికి ఇది సులభమైన పద్ధతి, ఇక్కడ తరగతి లోడింగ్ సమయంలో ఉదాహరణ సృష్టించబడుతుంది. ఈ పద్ధతిని ఉపయోగించి సింగిల్టన్ తరగతిని సృష్టించడానికి, మీరు క్రింద పేర్కొన్న దశలను అనుసరించాలి:

1. కన్స్ట్రక్టర్‌ను ప్రైవేట్‌గా ప్రకటించండి.
2. తదుపరి దశ ఈ సింగిల్టన్ తరగతి కోసం ప్రైవేట్ తరగతి సభ్యుడిని సృష్టించడం.
3. ఇప్పుడు, మీరు తరగతి సభ్యుని ఉదాహరణగా సృష్టించిన మీ తరగతి వస్తువును తిరిగి ఇవ్వడానికి ఉపయోగించే ఫ్యాక్టరీ పద్ధతిని మీరు నిర్వచించాలి.
4. మీరు ఈ స్టాటిక్ ఉదాహరణను నేరుగా యాక్సెస్ చేయాలనుకుంటే మీరు స్టాటిక్ మెంబర్ పబ్లిక్ అని కూడా ప్రకటించవచ్చు.

ఇప్పుడు, వీటిని ఎలా అమలు చేయాలో చూద్దాం.

// ఈజర్ ఇనిషియలైజేషన్ పబ్లిక్ క్లాస్ ఈజర్‌సింగిల్టన్ {ప్రైవేట్ స్టాటిక్ ఫైనల్ ఈజర్‌సింగిల్టన్ ఇన్‌స్టాన్స్ = కొత్త ఈజర్‌సింగిల్టన్ () ప్రైవేట్ ఈజర్‌సింగిల్టన్ ()}} పబ్లిక్ స్టాటిక్ ఈజర్‌సింగిల్టన్ గెట్ఇన్‌స్టాన్స్ () {రిటర్న్ ఇన్‌స్టాన్స్}}

మీరు కోడ్‌ను చూసినట్లయితే, ప్రతిసారీ మేము ఒక వస్తువును తక్షణం చేస్తున్నప్పుడు మీరు ఉపయోగించుకుంటున్నాముgetInstance ()తరగతిని ప్రారంభించడం కంటే పద్ధతి బిల్డర్ .కానీ దాని స్వంత నష్టాలు ఉన్నాయి. క్లాస్ సింగిల్టన్ చేయడానికి మీరు ఈ పద్ధతిని ఉపయోగిస్తే, అనువర్తనం దాన్ని ఉపయోగిస్తుందో లేదో అనే దానితో సంబంధం లేకుండా ఒక ఉదాహరణ సృష్టించబడుతుంది.

కాబట్టి, ముందుకు సాగండి మరియు జావాలో సింగిల్టన్ తరగతిని సృష్టించే మరో మార్గాన్ని చూద్దాం.

2. లేజీ ప్రారంభ విధానం

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

1. అన్నింటిలో మొదటిది, కన్స్ట్రక్టర్‌ను ప్రైవేట్గా ప్రకటించండి.
2. అప్పుడు మీరు ఈ తరగతి కోసం ఒక ప్రైవేట్ స్టాటిక్ ఉదాహరణను సృష్టించాలి, కాని దాన్ని ఇంకా తక్షణం చేయాల్సిన అవసరం లేదు.
3. చివరగా, ఫ్యాక్టరీ పద్ధతిని సృష్టించండి, ఇది ఉదాహరణ సభ్యుడు శూన్యమా కాదా అని మొదట తనిఖీ చేస్తుంది. కాకపోతే అది మీ కోసం సింగిల్టన్ క్లాస్ యొక్క ఉదాహరణను సృష్టించి తిరిగి ఇస్తుంది.

దీన్ని ఎలా చేయాలో క్రింద కోడ్ చూపిస్తుంది.

// లేజీ ప్రారంభించడం పబ్లిక్ క్లాస్ లేజీ సింగిల్టన్ {ప్రైవేట్ స్టాటిక్ లేజీ సింగిల్టన్ INSTANCE = శూన్య ప్రైవేట్ లేజీ సింగిల్టన్ ()}} పబ్లిక్ స్టాటిక్ లేజీ సింగిల్టన్ getInstance () {if (INSTANCE == null) {if (INSTANCE == null) {సమకాలీకరించబడింది (LazySingleton.class) {INSTANCE తిరిగి INSTANCE}}

3. థ్రెడ్ సేఫ్ సింగిల్టన్ విధానం

కానీ పై విధానం ఉమ్మడి దృశ్యాలలో కొన్ని ఆందోళనలను కలిగిస్తుంది. సింగిల్టన్ నమూనా ప్రధానంగా బహుళ-థ్రెడ్లతో ఉపయోగించబడుతుంది మరియు ఉంటేబహుళ థ్రెడ్లు ఒకేసారి if కండిషన్‌లోకి ప్రవేశిస్తే అది సమస్యలను లేవనెత్తుతుంది. దీన్ని నివారించడానికి గ్లోబల్ యాక్సెస్ పద్ధతిని సమకాలీకరించడం ద్వారా థ్రెడ్-సేఫ్ సింగిల్టన్ క్లాస్‌ను సృష్టించడానికి ప్రయత్నిస్తాము. ఏ సమయంలోనైనా ఒక థ్రెడ్ మాత్రమే ఈ పద్ధతిని అమలు చేస్తుందని ఇది నిర్ధారిస్తుంది. అమలును చూడటానికి క్రింది కోడ్‌ను చూడండి:

// థ్రెడ్ సేఫ్ సింగిల్టన్ పబ్లిక్ క్లాస్ థ్రెడ్ సేఫ్ సింగిల్టన్ {ప్రైవేట్ స్టాటిక్ థ్రెడ్ సేఫ్ సింగిల్టన్ ప్రైవేట్ థ్రెడ్ సేఫ్ సింగిల్టన్ ()}} పబ్లిక్ స్టాటిక్ సింక్రొనైజ్డ్ థ్రెడ్ సేఫ్ సింగిల్టన్ గెట్ఇన్స్టాన్స్ () {if (INSTANCE == null) {INSTANCE = new ThreadSafeSing} తిరిగి

కానీ కొన్ని సార్లు ఈ విధానం ప్రతిసారీ పద్ధతి వలె చాలా గజిబిజిగా మారుతుందిఆరంభించబడినది, పద్ధతి ఉపయోగించటానికి ముందు లాక్ విడుదలయ్యే వరకు వేచి ఉండాలి. ఇది ప్రక్రియను మందగించి, తదుపరి విధానానికి దారి తీస్తుందిడబుల్ లాక్‌తో లేజీ ప్రారంభించడం.

4. డబుల్ లాక్‌తో లేజీ ప్రారంభించడం విధానం

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

// డబుల్ లాక్‌తో లేజీ ప్రారంభించడం పబ్లిక్ క్లాస్ లేజీడబుల్ లాక్ సింగిల్టన్ {ప్రైవేట్ స్టాటిక్ లేజీడబుల్ లాక్ సింగిల్టన్ INSTANCE = శూన్య ప్రైవేట్ లేజీడబుల్ లాక్ సింగిల్టన్ ()}} పబ్లిక్ స్టాటిక్ లేజీడౌబుల్ లాక్ సింగిల్టన్ getInstance () {if = శూన్య) {INSTANCE = క్రొత్త LazyDoubleLockSingleton ()}}} తిరిగి INSTANCE}}

5. లేజీ లోడ్ విధానం

ఈ పద్ధతి JSL (జావా లాంగ్వేజ్ స్పెసిఫికేషన్) పై ఆధారపడి ఉంటుంది మరియు దీని ప్రకారం స్టాటిక్ డేటా సభ్యులకు అవసరమైనప్పుడు మాత్రమే వాటిని లోడ్ చేస్తుంది. మీ సింగిల్టన్ క్లాస్ JVM లోకి లోడ్ అయినప్పుడు, ఉదాహరణ సృష్టించబడదు. ఇంకా, ప్రోగ్రామ్ అమలు సమయంలో, గ్లోబల్ పద్దతి వరుస క్రమంలో ఉపయోగించబడుతుంది. ఈ పద్ధతిలో, లోడ్ చేయడానికి మరియు ప్రారంభించడానికి మీరు స్టాటిక్ getInstance () ను స్పష్టంగా సమకాలీకరించాల్సిన అవసరం లేదు. స్టాటిక్ క్లాస్ సభ్యుడిని సరైన క్రమంలో అమలు చేస్తారు, గ్లోబల్ పద్ధతి యొక్క మిగిలిన ఏకకాల ఆహ్వానాలు సమకాలీకరణ ఓవర్ హెడ్ చేయకుండానే అదే క్రమంలో తిరిగి ఇవ్వబడతాయి.

అదే పని చేయడానికి కోడ్ క్రింద ఉంది.

// లేజీ లోడ్ విధానం పబ్లిక్ క్లాస్ లేజీలోడ్ సింగిల్టన్ {ప్రైవేట్ లేజీలోడ్ సింగిల్టన్ ()}} ప్రైవేట్ స్టాటిక్ క్లాస్ సింగిల్టన్ క్లాస్హోల్డర్ {స్టాటిక్ ఫైనల్ వర్ ఇన్స్టాన్స్ = కొత్త లేజీలోడ్ సింగిల్టన్ ()} పబ్లిక్ స్టాటిక్ లేజీలోడ్ సింగిల్టన్ గెట్ఇన్స్టాన్స్ () {రిటర్న్} సింగిల్టన్ క్లాస్.

6. స్టాటిక్ బ్లాక్ ప్రారంభ విధానం

జావాలో సింగిల్టన్ తరగతిని సృష్టించే ఈ పద్ధతిఆసక్తిగల ప్రారంభ పద్ధతి మాదిరిగానే. ఒకే తేడా ఏమిటంటే, ఈ తరగతికి ఉదాహరణ స్టాటిక్ బ్లాక్ కలిగి ఉన్నప్పుడే సృష్టించబడుతుంది కార్యాచరణ.

// స్టాటిక్ బ్లాక్ ప్రారంభించడం పబ్లిక్ క్లాస్ స్టాటిక్బ్లాక్ సింగిల్టన్ {ప్రైవేట్ స్టాటిక్ స్టాటిక్బ్లాక్ సింగిల్టన్ ఇన్స్టాన్స్ ప్రైవేట్ స్టాటిక్బ్లాక్ సింగిల్టన్ () {} // స్టాటిక్ బ్లాక్ స్టాటిక్ లోపల మినహాయింపు నిర్వహణ {ప్రయత్నించండి {INSTANCE = కొత్త స్టాటిక్బ్లాక్ సింగిల్టన్ ()} క్యాచ్ (మినహాయింపు ఇ) new కొత్త రన్టైమ్ ఎక్సెప్షన్ ('మినహాయింపు సంభవించింది సింగిల్టన్ క్లాస్‌ను సృష్టించేటప్పుడు ')}} పబ్లిక్ స్టాటిక్ స్టాటిక్బ్లాక్ సింగిల్టన్ getInstance () {తిరిగి INSTANCE}}

ఇది జావాలోని సింగిల్టన్ తరగతిపై ఈ వ్యాసం చివరకి మనలను తీసుకువస్తుంది. మీరు జావా గురించి మరింత తెలుసుకోవాలంటే మీరు మా చూడండి .

మార్పిడి రకం ++

జావాలో సింగిల్టన్ క్లాస్ అంటే ఏమిటో ఇప్పుడు మీరు అర్థం చేసుకున్నారు, చూడండి ప్రపంచవ్యాప్తంగా 250,000 కంటే ఎక్కువ సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలోని సింగిల్టన్ క్లాస్” వ్యాసంలోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.