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

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

Cat cat = new Cat();// Our Cat object's lifecycle begins now!

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

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(), "లంబోర్ఘిని డయాబ్లో" కారు వస్తువు రెండవ లైన్‌లో సజీవంగా ఉండదు. దీనికి ఒకే ఒక సూచన ఉంది మరియు సూచన శూన్యంగా సెట్ చేయబడింది. డయాబ్లోకు మిగిలిన సూచనలు లేనందున, అది "చెత్త" అవుతుంది. ఇది జరగడానికి సూచనను సున్నాకి సెట్ చేయవలసిన అవసరం లేదు:

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 Gallardo, కానీ Lamborghini Diabloవస్తువుకు ఏదీ లేదు. దీని అర్థం Diabloవస్తువు చెత్తగా మారుతుంది. జావా యొక్క అంతర్నిర్మిత చెత్త కలెక్టర్ (GC) ప్రారంభించినప్పుడు ఇది జరుగుతుంది. చెత్త కలెక్టర్ అనేది మెమరీని ఖాళీ చేయడానికి బాధ్యత వహించే అంతర్గత జావా మెకానిజం, అనగా మెమరీ నుండి అనవసరమైన వస్తువులను తొలగించడం. మేము దానిని రోబోట్ వాక్యూమ్ క్లీనర్‌తో సూచించడానికి ఎంచుకోవడానికి ఒక కారణం ఉంది. చెత్త కలెక్టర్ దాదాపు అదే విధంగా పని చేస్తుంది: ఇది చెత్తను సేకరిస్తూ నేపథ్యంలో మీ ప్రోగ్రామ్‌ను "కదిలిస్తుంది". మీరు ఆచరణాత్మకంగా దానితో పరస్పర చర్య చేయవలసిన అవసరం లేదు. ప్రోగ్రామ్‌లో ఉపయోగించని వస్తువులను తొలగించడం దీని పని. అందువలన, ఇది ఇతర వస్తువులకు మెమరీని ఖాళీ చేస్తుంది. నిజ జీవితంలో మేము చెప్పిన పాఠం ప్రారంభంలో మీరు మీ కంప్యూటర్ స్థితిని పర్యవేక్షించాలని మరియు పాత ఫైల్‌లను తొలగించాలని మీకు గుర్తుందా? మేము జావా వస్తువుల గురించి మాట్లాడుతున్నట్లయితే, చెత్త కలెక్టర్ మీ కోసం దీన్ని చేస్తారు. మీ ప్రోగ్రామ్ అమలవుతున్నప్పుడు చెత్త కలెక్టర్ చాలాసార్లు ప్రారంభించబడుతుంది: మీరు దీన్ని స్పష్టంగా కాల్ చేసి, ఆదేశాలను ఇవ్వాల్సిన అవసరం లేదు (ఇది సాంకేతికంగా సాధ్యమే అయినప్పటికీ). మేము చెత్త కలెక్టర్ గురించి తర్వాత మరింత మాట్లాడతాము మరియు అది ఎలా పని చేస్తుందో మరింత వివరంగా విశ్లేషిస్తాము. చెత్త సేకరించేవాడు ఒక వస్తువును చేరుకున్నప్పుడు-అది నాశనం చేయబడే ముందు-వస్తువు యొక్క ప్రత్యేక finalize()పద్ధతి అంటారు. ఆబ్జెక్ట్ ఉపయోగించే కొన్ని అదనపు వనరులను విడుదల చేయడానికి ఈ పద్ధతిని ఉపయోగించవచ్చు. పద్ధతి finalize()ఆబ్జెక్ట్ క్లాస్‌కు చెందినది. మరో మాటలో చెప్పాలంటే, ఇది equals(), hashCode()మరియు toString()(మీరు ఇంతకు ముందు కలుసుకున్నది) పోలి ఉంటుంది. ప్రతి వస్తువుకు అది ఉంటుంది . అందులో ఇతర పద్ధతులకు భిన్నంగా ఉంటుంది...దీన్ని ఎలా చెప్పాలి...చాలా సంకల్పం. దాని ద్వారా మనం అర్థం చేసుకున్నాంఒక వస్తువు నాశనం చేయబడే ముందు అది ఎల్లప్పుడూ పిలువబడదు . ప్రోగ్రామింగ్ అనేది చాలా ఖచ్చితమైన కార్యకలాపం. ప్రోగ్రామర్ కంప్యూటర్‌కు ఏదైనా చేయమని చెబుతాడు మరియు కంప్యూటర్ దానిని చేస్తుంది. మీరు ఈ విధమైన ప్రవర్తనకు అలవాటు పడ్డారని నేను ఊహిస్తున్నాను, కాబట్టి మొదట ఈ క్రింది ఆలోచనను అంగీకరించడం మీకు కష్టంగా ఉండవచ్చు: "ఒక వస్తువు నాశనం చేయబడటానికి ముందు, ఆబ్జెక్ట్ క్లాస్ యొక్క పద్ధతి అంటారు. లేదా కాదు. మనం అదృష్టవంతులైతే 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;// The first object becomes available for garbage collection here
       }
   }

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

మేము ఒక Catవస్తువును సృష్టిస్తాము మరియు తదుపరి పంక్తిలో దానికి సంబంధించిన ఏకైక సూచనను సున్నా చేస్తాము. మరియు మేము దానిని మిలియన్ సార్లు చేస్తాము. మేము finalize()పద్ధతిని స్పష్టంగా భర్తీ చేసాము. ఒక వస్తువు నాశనం చేయబడిన ప్రతిసారీ Cat, అది ఒక స్ట్రింగ్‌ను ప్రదర్శించాలి-మొత్తం ఒక మిలియన్ సార్లు. కానీ కాదు! ఖచ్చితంగా చెప్పాలంటే, నా కంప్యూటర్‌లో ఇది 37346 సార్లు మాత్రమే అమలు చేయబడింది! finalize()మరో మాటలో చెప్పాలంటే, నా జావా యంత్రం ప్రతి 27 కేసులలో 1 మాత్రమే పద్ధతిని పిలవాలని నిర్ణయించుకుంది . ఇతర సందర్భాల్లో, చెత్త సేకరణలో ఈ కాల్ ప్రమేయం లేదు. ఈ కోడ్‌ని మీరే అమలు చేయడానికి ప్రయత్నించండి. మీరు చాలా మటుకు భిన్నమైన ఫలితాన్ని పొందుతారు. మీరు చూడగలిగినట్లుగా, finalize()నమ్మదగిన భాగస్వామిని పిలవడం కష్టం :) కాబట్టి, భవిష్యత్తు కోసం ఇక్కడ ఒక చిన్న చిట్కా ఉంది: క్లిష్టమైన వనరులను విడుదల చేయడానికి పద్ధతిపై ఆధారపడవద్దు .finalize()JVM దీన్ని పిలవవచ్చు లేదా కాకపోవచ్చు. ఎవరికీ తెలుసు? మీ వస్తువు సజీవంగా ఉన్నప్పుడు కొన్ని పనితీరు-క్లిష్టమైన వనరులను (ఉదాహరణకు, ఓపెన్ డేటాబేస్ కనెక్షన్) కలిగి ఉంటే, ఆబ్జెక్ట్ ఇకపై అవసరం లేనప్పుడు వాటిని విడుదల చేయడానికి ప్రత్యేక పద్ధతిని సృష్టించడం మరియు స్పష్టంగా కాల్ చేయడం మంచిది. ఆ విధంగా, మీ ప్రోగ్రామ్ పనితీరు దెబ్బతినదని మీకు ఖచ్చితంగా తెలుస్తుంది. జ్ఞాపకశక్తితో పని చేయడం మరియు చెత్త సేకరణ చాలా ముఖ్యమైన అంశాలు అని చెప్పడం ద్వారా మేము ప్రారంభించాము మరియు వాస్తవానికి అవి. వనరులను తప్పుగా నిర్వహించడం మరియు అనవసరమైన వస్తువులు ఎలా శుభ్రం చేయబడతాయో తప్పుగా అర్థం చేసుకోవడం అత్యంత అసహ్యకరమైన బగ్‌లలో ఒకదానికి దారి తీస్తుంది: మెమరీ లీక్‌లు . ఇది బాగా తెలిసిన ప్రోగ్రామింగ్ లోపాలలో ఒకటి. దాని స్వంత వికీపీడియా కథనం కూడా ఉంది. పేలవంగా వ్రాసిన కోడ్ ప్రతిసారీ కొత్తగా సృష్టించబడిన వస్తువులకు మెమరీని కేటాయించే పరిస్థితిని సృష్టించగలదు, అయితే చెత్త సేకరణకు పాత, అనవసరమైన వస్తువులు అందుబాటులో ఉండవు. మేము ఇప్పటికే రోబోట్ వాక్యూమ్ క్లీనర్ సారూప్యతను తయారు చేసాము కాబట్టి, రోబోట్‌ను నడపడానికి ముందు మీరు ఇంటినిండా సాక్స్‌లను చల్లి, ఒక గాజు కుండీని పగులగొట్టి, లెగో ముక్కలను నేలపై ఉంచినట్లయితే ఏమి జరుగుతుందో ఊహించండి. సహజంగానే, రోబోట్ ఏదైనా చేయాలని ప్రయత్నిస్తుంది, కానీ ఒక రోజు అది స్వాధీనం చేసుకుంటుంది. వాక్యూమ్ క్లీనర్ సరిగ్గా పనిచేయడానికి, మీరు నేలను మంచి ఆకృతిలో ఉంచాలి మరియు అది నిర్వహించలేని ప్రతిదాన్ని తీయాలి. చెత్త సేకరించేవాడు కూడా అదే సూత్రాన్ని అనుసరిస్తాడు. ప్రోగ్రామ్‌లో శుభ్రం చేయలేని అనేక వస్తువులు ఉంటే (మన రోబోటిక్ వాక్యూమ్ క్లీనర్ కోసం సాక్ లేదా లెగో వంటివి), ఒక రోజు మన మెమరీ అయిపోతుంది. మీ ప్రోగ్రామ్ హ్యాంగ్ అవ్వడమే కాదు, కంప్యూటర్‌లో రన్ అయ్యే అన్ని ఇతర ప్రోగ్రామ్‌లు కూడా ఉంటాయి. అన్నింటికంటే, వారికి తగినంత జ్ఞాపకశక్తి కూడా ఉండదు (మా సారూప్యతకు తిరిగి రావడం, నేలపై విరిగిన గాజు వాక్యూమ్ క్లీనర్‌ను మాత్రమే కాకుండా, ఇంటిలో నివసించే వ్యక్తులను కూడా ఆపివేస్తుంది). సంక్షిప్తంగా, జావాలో వస్తువు జీవితచక్రం మరియు చెత్త సేకరణ ఇలా ఉంటుంది. మీరు దీన్ని గుర్తుంచుకోవలసిన అవసరం లేదు: ఇది ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి సరిపోతుంది. తదుపరి పాఠంలో, మేము మరింత వివరంగా ఈ ప్రక్రియలకు తిరిగి వస్తాను. కానీ ప్రస్తుతానికి, మీరు CodeGym పనులను పరిష్కరించడానికి తిరిగి రావచ్చు :) అదృష్టం!