చెత్త సేకరణ

"హాయ్! చెత్త సేకరణ గురించి మీకు మరో చిన్న పాఠం చెప్పాలని నిర్ణయించుకున్నాను."

మీకు ఇప్పటికే తెలిసినట్లుగా, ఒక వస్తువు అనవసరమైనప్పుడు జావా యంత్రం స్వయంగా పర్యవేక్షిస్తుంది మరియు దానిని తొలగిస్తుంది.

"అవును. నువ్వూ, రిషి దాని గురించి నాకు ముందే చెప్పారు. నాకు వివరాలు గుర్తు లేవు."

"సరే. అప్పుడు మళ్ళీ వెళ్దాం."

"ఒక వస్తువు సృష్టించబడిన వెంటనే, JVM దాని కోసం మెమరీని కేటాయిస్తుంది. ఆబ్జెక్ట్‌పై ఆసక్తిని రిఫరెన్స్ వేరియబుల్స్ ఉపయోగించి పర్యవేక్షిస్తుంది.  చెత్త సేకరణ సమయంలో ఒక వస్తువును తొలగించవచ్చు, అనగా వేరియబుల్‌లను సూచించే వేరియబుల్స్ లేనట్లయితే మెమరీని విడుదల చేసే విధానం. వస్తువు. "

"చెత్త కలెక్టర్ గురించి కొంచెం చెప్పండి-ఇది ఏమిటి మరియు ఇది ఎలా పని చేస్తుంది."

"సరే. చెత్త సేకరణ ప్రధాన థ్రెడ్‌లో జరిగేది. ప్రతి 5 నిమిషాలకు లేదా అంతకంటే ఎక్కువ సార్లు. ఎప్పుడైనా తగినంత ఉచిత మెమరీ లేకపోతే, జావా మెషీన్ అన్ని థ్రెడ్‌లను సస్పెండ్ చేస్తుంది మరియు ఉపయోగించని వస్తువులను తొలగిస్తుంది."

"కానీ ఇప్పుడు ఈ విధానం విరమించబడింది. నెక్స్ట్-జెన్ గార్బేజ్ కలెక్టర్ తెరవెనుక మరియు ప్రత్యేక థ్రెడ్‌లో పని చేస్తారు. దీనిని ఉమ్మడి చెత్త సేకరణ అంటారు."

"నేను చూస్తున్నాను. ఆబ్జెక్ట్‌ని తొలగించాలా వద్దా అనే నిర్ణయం సరిగ్గా ఎలా ఉంది?"

"ఒక వస్తువుకు సూచనల సంఖ్యను లెక్కించడం చాలా ప్రభావవంతంగా ఉండదు-ఒకదానికొకటి సూచించే వస్తువులు ఉండవచ్చు, కానీ ఇతర వస్తువులు ఏవీ సూచించబడవు."

"కాబట్టి జావా వేరొక విధానాన్ని తీసుకుంటుంది.  జావా ఆబ్జెక్ట్‌లను రీచబుల్ మరియు అన్‌రీచబుల్‌గా విభజిస్తుంది.  ఒక వస్తువు మరొక రీచ్ చేయగల (జీవించే) ఆబ్జెక్ట్ ద్వారా రిఫరెన్స్ చేయబడితే రీచబుల్ (సజీవంగా) ఉంటుంది. థ్రెడ్‌ల నుండి రీచబిలిటీ నిర్ణయించబడుతుంది. రన్నింగ్ థ్రెడ్‌లు ఎల్లప్పుడూ రీచ్‌బుల్ (సజీవంగా) పరిగణించబడతాయి. , ఎవరూ వాటిని ప్రస్తావించనప్పటికీ."

"సరే. నాకు అర్థమైంది."

"అసలు చెత్త సేకరణ ఎలా జరుగుతుంది-అనవసరమైన వస్తువులను తొలగించడం?"

"ఇది చాలా సులభం. జావాలో, జ్ఞాపకశక్తి సమావేశం ద్వారా రెండు భాగాలుగా విభజించబడింది మరియు చెత్త సేకరణకు సమయం వచ్చినప్పుడు, అన్ని సజీవ (చేరగలిగే) వస్తువులు మెమరీలోని మరొక భాగానికి కాపీ చేయబడతాయి మరియు పాత మెమరీ మొత్తం విడుదల చేయబడుతుంది."

"ఇది ఒక ఆసక్తికరమైన విధానం. సూచనలను లెక్కించాల్సిన అవసరం లేదు: అందుబాటులో ఉన్న అన్ని వస్తువులను కాపీ చేయండి మరియు మిగతావన్నీ చెత్త."

"ఇది దాని కంటే కొంచెం క్లిష్టంగా ఉంటుంది. జావా ప్రోగ్రామర్లు వస్తువులను సాధారణంగా రెండు వర్గాలుగా విభజించారని కనుగొన్నారు: దీర్ఘకాలం (ప్రోగ్రామ్ నడుస్తున్న మొత్తం సమయం వరకు ఇవి ఉంటాయి) మరియు స్వల్పకాలికమైనవి (పద్ధతులలో మరియు "స్థానిక పనితీరు కోసం ఇవి అవసరం. » కార్యకలాపాలు)."

"దీర్ఘకాలిక వస్తువులను స్వల్పకాలిక వస్తువుల నుండి వేరుగా ఉంచడం చాలా సమర్థవంతమైనది. దీన్ని చేయడానికి, వస్తువు యొక్క దీర్ఘాయువును నిర్ణయించడానికి ఒక మార్గాన్ని రూపొందించడం అవసరం."

"కాబట్టి, వారు మొత్తం మెమరీని «తరాలు»గా విభజించారు. మొదటి తరం వస్తువులు, రెండవ తరం వస్తువులు మొదలైనవి ఉన్నాయి. మెమరీని క్లియర్ చేసిన ప్రతిసారీ, జనరేషన్ కౌంటర్ 1 ద్వారా పెరుగుతుంది. కొన్ని వస్తువులు బహుళ తరాలలో ఉంటే, అప్పుడు అవి దీర్ఘాయువుగా నమోదు చేయబడ్డాయి."

"నేడు, చెత్త సేకరించేవాడు జావాలో చాలా సంక్లిష్టమైన మరియు సమర్థవంతమైన భాగం. దానిలోని చాలా భాగాలు హ్యూరిస్టిక్‌గా పనిచేస్తాయి-అనుమానాలను రూపొందించే అల్గారిథమ్‌ల ఆధారంగా. ఫలితంగా, ఇది తరచుగా వినియోగదారుని "వినడం లేదు."

"అర్థం?"

"జావాలో చెత్త కలెక్టర్ ( GC ) వస్తువు ఉంది, దానిని System.gc () పద్ధతిని ఉపయోగించి పిలవవచ్చు ."

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

"ఓహో! తెలుసుకోవడం మంచిది."

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

"మరియు, చూడండి. జావాలో మీరు ఈ ప్రక్రియను ప్రభావితం చేసే ప్రత్యేక సూచనలు ఉన్నాయి. వాటి కోసం ప్రత్యేక రేపర్ తరగతులు ఉన్నాయి. అవి ఇక్కడ ఉన్నాయి:"

" సాఫ్ట్ రిఫరెన్స్  ఒక మృదువైన సూచన."

" బలహీనమైన సూచన  బలహీనమైన సూచన."

" ఫాంటమ్ రిఫరెన్స్ ఒక ఫాంటమ్ రిఫరెన్స్."

"ఉహ్... ఇది నాకు అంతర్గత తరగతులు, సమూహ తరగతులు, సమూహ అనామక తరగతులు మరియు స్థానిక తరగతులను గుర్తుచేస్తుంది. పేర్లు భిన్నంగా ఉన్నాయి, కానీ అవి దేనికి సంబంధించినవి అనేది స్పష్టంగా తెలియదు."

"చెప్పండి, అమిగో, మీరు ప్రోగ్రామర్ అయ్యారు. ఇప్పుడు మీరు తరగతి పేర్ల కారణంగా కోపంగా ఉన్నారు, "అవి తగినంత సమాచారంగా లేవు మరియు ఈ తరగతి ఏమి చేస్తుందో, ఎలా చేస్తుందో నిర్ణయించడం ఒక పేరుతో(!) అసాధ్యం మరియు ఎందుకు"."

"వావ్. నేను కూడా గమనించలేదు. కానీ ఇది చాలా స్పష్టంగా ఉంది."

"సరే. కావలసినంత పదాలు. సాఫ్ట్‌రిఫరెన్స్‌ల గురించి చెబుతాను."

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

"అటువంటి సూచన యొక్క ఉదాహరణ ఇక్కడ ఉంది:"

// Create a Cat object
Cat cat = new Cat();

// Create a soft reference to a Cat object
SoftReference<Cat> catRef = new SoftReference<Cat>(cat);

// Now only the catRef soft reference points at the object
cat = null;

// Now the ordinary cat variable also references the object
cat = catRef.get();

// Clear the soft reference
catRef.clear();

"ఒక వస్తువుకు సంబంధించిన ఏకైక సూచనలు మృదువుగా ఉంటే, అది జీవిస్తూనే ఉంటుంది మరియు దానిని 'సాఫ్ట్లీ-రీచబుల్' అంటారు."

"కానీ!  సాఫ్ట్ రిఫరెన్స్‌ల ద్వారా మాత్రమే సూచించబడిన వస్తువును ప్రోగ్రామ్‌కు తగినంత మెమరీ లేకపోతే చెత్త కలెక్టర్ తొలగించవచ్చు.  అకస్మాత్తుగా ప్రోగ్రామ్‌కు తగినంత మెమరీ లేకపోతే, OutOfMemoryExceptionని విసిరే ముందు , చెత్త కలెక్టర్ అన్ని వస్తువులను తొలగిస్తుంది. సాఫ్ట్ రిఫరెన్స్‌ల ద్వారా సూచించబడింది మరియు ప్రోగ్రామ్‌కు మెమరీని కేటాయించడానికి మళ్లీ ప్రయత్నిస్తుంది."

"ఒక క్లయింట్ ప్రోగ్రామ్ తరచుగా సర్వర్ ప్రోగ్రామ్ నుండి వివిధ డేటాను అభ్యర్థిస్తుందనుకుందాం. సర్వర్ ప్రోగ్రామ్ సాఫ్ట్‌రిఫరెన్స్‌ని ఉపయోగించి కొంత భాగాన్ని కాష్ చేయగలదు. సాఫ్ట్ రిఫరెన్స్‌ల ద్వారా మరణం నుండి ఉంచబడిన వస్తువులు మెమరీలో ఎక్కువ భాగాన్ని తీసుకుంటే, చెత్త సేకరించేవాడు వాటిని తొలగిస్తాడు. అంతా. అందంగా ఉంది!"

"అవును. నాకే నచ్చింది."

"సరే, ఒక చిన్న అదనంగా: SoftReference తరగతికి రెండు పద్ధతులు ఉన్నాయి. Get() పద్ధతి SoftReference ద్వారా సూచించబడిన వస్తువును అందిస్తుంది . ఆ వస్తువును చెత్త సేకరించేవాడు తొలగించినట్లయితే, get ( ) పద్ధతి అకస్మాత్తుగా శూన్యతను తిరిగి ఇవ్వడం ప్రారంభిస్తుంది."

"క్లియర్() పద్ధతికి కాల్ చేయడం ద్వారా వినియోగదారు సాఫ్ట్‌రిఫరెన్స్‌ను స్పష్టంగా క్లియర్ చేయవచ్చు. ఈ సందర్భంలో, సాఫ్ట్‌రిఫరెన్స్ ఆబ్జెక్ట్‌లోని బలహీనమైన లింక్ నాశనం చేయబడుతుంది."

"ఇప్పటికి ఇంతే."

"ఆసక్తికరమైన కథనానికి ధన్యవాదాలు, ఎల్లీ. ఇది నిజంగా చాలా ఆసక్తికరంగా ఉంది."