వస్తువు జీవితచక్రం

హాయ్!

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

నిజమైన పెద్ద ప్రోగ్రామ్‌లో, పదుల మరియు వందల వేల వస్తువులు సృష్టించబడతాయి మరియు వాటిలో ప్రతి ఒక్కటి దాని స్వంత మెమరీని కలిగి ఉంటాయి. కానీ ఈ వస్తువులన్నీ ఎంతకాలం ఉన్నాయని మీరు అనుకుంటున్నారు? మా ప్రోగ్రామ్ నడుస్తున్న మొత్తం సమయం వారు "లైవ్" చేస్తారా? అస్సలు కానే కాదు. జావా ఆబ్జెక్ట్‌ల యొక్క అన్ని ప్రయోజనాలు ఉన్నప్పటికీ, అవి శాశ్వతమైనవి కావు :) వస్తువులకు వాటి స్వంత జీవితచక్రం ఉంటుంది. ఈ రోజు మనం కోడ్ రాయడం నుండి కొంచెం విరామం తీసుకుంటాము మరియు ఈ ప్రక్రియను పరిశీలిస్తాము :) అంతేకాకుండా, ప్రోగ్రామ్ ఎలా పని చేస్తుంది మరియు వనరులు ఎలా నిర్వహించబడుతున్నాయి అనే దానిపై మీ అవగాహనకు ఇది చాలా ముఖ్యం. కాబట్టి, ఒక వస్తువు యొక్క జీవితం ఎప్పుడు ప్రారంభమవుతుంది? ఒక వ్యక్తి వలె - దాని పుట్టుక నుండి, అంటే సృష్టి.

Cat cat = new Cat(); // Here the lifecycle of our Cat object begins!

మొదట, జావా వర్చువల్ మెషిన్ ఆబ్జెక్ట్‌ను సృష్టించడానికి అవసరమైన మెమరీని కేటాయిస్తుంది. అప్పుడు అది ఆ మెమరీకి సూచనను సృష్టిస్తుంది. మా విషయంలో, ఆ సూచన అంటారు cat, కాబట్టి మనం దానిని ట్రాక్ చేయవచ్చు. అప్పుడు దాని అన్ని వేరియబుల్స్ ప్రారంభించబడతాయి, కన్స్ట్రక్టర్ అంటారు, మరియు — ta-da! — మన కొత్తగా ముద్రించిన వస్తువు దాని స్వంత జీవితాన్ని గడుపుతోంది :)

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

public class Car {
  
   String model;

   public Car(String model) {
       this.model = model;
   }

   public static void main(String[] args) {
       Car lamborghini  = new Car("Lamborghini Diablo");
       lamborghini = null;

   }

}

లంబోర్ఘిని డయాబ్లో కారు వస్తువు main()పద్ధతి యొక్క రెండవ లైన్‌లో సజీవంగా ఉండటం ఆగిపోతుంది. దానికి ఒకే ఒక సూచన ఉంది, ఆపై ఆ సూచనకు సమానంగా సెట్ చేయబడింది null. లంబోర్ఘిని డయాబ్లోకు సంబంధించి మిగిలిన సూచనలు లేనందున, కేటాయించిన మెమరీ "చెత్త"గా మారుతుంది. ఇది జరగడానికి సూచనను శూన్యంగా సెట్ చేయవలసిన అవసరం లేదు:

public class Car {

   String model;

   public Car(String model) {
       this.model = model;
   }

   public static void main(String[] args) {
       Car lamborghini  = new Car("Lamborghini Diablo");

       Car lamborghiniGallardo = new Car("Lamborghini Gallardo");
       lamborghini = lamborghiniGallardo;
   }

}

ఇక్కడ మేము రెండవ ఆబ్జెక్ట్‌ను సృష్టించాము మరియు ఈ కొత్త వస్తువును సూచనకు కేటాయించాము lamborghini. ఇప్పుడు Lamborghini Gallardoవస్తువుకు రెండు సూచనలు ఉన్నాయి, కానీ Lamborghini Diabloవస్తువుకు ఏదీ లేదు. అంటే ఆ Diabloవస్తువు ఇప్పుడు చెత్తగా ఉంది. ఈ సమయంలో జావా యొక్క అంతర్నిర్మిత యంత్రాంగాన్ని చెత్త కలెక్టర్ (GC) అని పిలుస్తారు.

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

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

చెత్త సేకరించేవాడు ఒక వస్తువును చేరుకున్నప్పుడు, వస్తువును నాశనం చేసే ముందు, అది finalize()వస్తువుపై ఒక ప్రత్యేక పద్ధతిని — — అని పిలుస్తుంది. ఈ పద్ధతి ఆబ్జెక్ట్ ఉపయోగించే ఇతర వనరులను విడుదల చేయగలదు. పద్ధతి finalize()తరగతిలో భాగం Object. అంటే మీరు గతంలో కలుసుకున్న equals(), hashCode()మరియు పద్ధతులతో పాటు, ప్రతి వస్తువుకు ఈ పద్ధతి ఉంటుంది. toString()ఇది ఇతర పద్ధతుల నుండి భిన్నంగా ఉంటుంది - నేను దీన్ని ఎలా ఉంచాలి - చాలా మోజుకనుగుణంగా ఉంటుంది.

ప్రత్యేకించి, ఒక వస్తువు యొక్క నాశనానికి ముందు ఇది ఎల్లప్పుడూ పిలువబడదు. ప్రోగ్రామింగ్ ఒక ఖచ్చితమైన ప్రయత్నం. ప్రోగ్రామర్ కంప్యూటర్‌కు ఏదైనా చేయమని చెబుతాడు మరియు కంప్యూటర్ దానిని చేస్తుంది. మీరు ఇప్పటికే ఈ ప్రవర్తనకు అలవాటు పడ్డారని నేను అనుకుంటాను, కాబట్టి మొదట మీరు ఈ క్రింది ఆలోచనను అంగీకరించడం కష్టం కావచ్చు: "వస్తువులను నాశనం చేయడానికి ముందు, తరగతి యొక్క పద్ధతిని finalize()పిలుస్తారు Object. లేదా దానిని పిలవకపోవచ్చు. ఇది అన్నింటిపై ఆధారపడి ఉంటుంది. నీ అదృష్టం!"

అయినప్పటికీ, ఇది నిజం. finalize()జావా మెషీన్ స్వయంగా కేస్-బై-కేస్ ఆధారంగా పద్ధతిని కాల్ చేయాలా వద్దా అని నిర్ణయిస్తుంది . ఉదాహరణకు, కింది కోడ్‌ను ప్రయోగంగా అమలు చేయడానికి ప్రయత్నిద్దాం:

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public Cat() {
   }

   public static void main(String[] args) throws Throwable {
       for (int i = 0 ; i < 1000000; i++) {
           Cat cat = new Cat();
           cat = null; // This is when the first object becomes available to the garbage collector
       }
   }

   @Override
   protected void finalize() throws Throwable {
       System.out.println("Cat object destroyed!");
   }
}

మేము Catఆబ్జెక్ట్‌ను సృష్టించి, ఆపై కోడ్ యొక్క తదుపరి లైన్‌లో దాని ఏకైక సూచనను శూన్యానికి సమానంగా సెట్ చేస్తాము. మరియు మేము దానిని మిలియన్ సార్లు చేస్తాము. మేము పద్ధతిని స్పష్టంగా ఓవర్‌రోడ్ చేసాము finalize(), తద్వారా అది ఒక స్ట్రింగ్‌ను కన్సోల్‌కి మిలియన్ సార్లు ప్రింట్ చేస్తుంది (ప్రతి సారి అది ఒక Catవస్తువును నాశనం చేస్తుంది). కానీ కాదు! ఖచ్చితంగా చెప్పాలంటే, ఇది నా కంప్యూటర్‌లో 37,346 సార్లు మాత్రమే నడిచింది! అంటే, నా మెషీన్‌లో ఇన్‌స్టాల్ చేయబడిన జావా మెషీన్ 27 సార్లు ఒకసారి పద్ధతిని పిలవాలని నిర్ణయించుకుంది finalize().

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

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

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

రోబోట్ వాక్యూమ్ క్లీనర్ సరిగ్గా పనిచేయడానికి, మీరు నేలను మంచి స్థితిలో ఉంచాలి మరియు రోబోట్ నిర్వహించలేని ఏదైనా తీసివేయాలి. ఇదే సూత్రం జావా చెత్త సేకరణకు కూడా వర్తిస్తుంది. ప్రోగ్రామ్‌లో శుభ్రం చేయలేని అనేక వస్తువులు మిగిలి ఉంటే (మా రోబోట్ వాక్యూమ్ క్లీనర్ కోసం సాక్ లేదా లెగో బిల్డింగ్ బ్లాక్ వంటివి), ఏదో ఒక సమయంలో మీ మెమరీ అయిపోతుంది. మరియు అది స్తంభింపజేసే మీ ప్రోగ్రామ్ మాత్రమే కాదు - కంప్యూటర్‌లో నడుస్తున్న ప్రతి ఇతర ప్రోగ్రామ్ ప్రభావితం కావచ్చు. వారికి కూడా తగినంత జ్ఞాపకశక్తి లేకపోవచ్చు.

మీరు దీన్ని గుర్తుంచుకోవలసిన అవసరం లేదు. ఇది ఎలా పని చేస్తుందో దాని వెనుక ఉన్న సూత్రాన్ని మీరు అర్థం చేసుకోవాలి.