குப்பை சேகரிப்பு

"ஹாய்! குப்பை சேகரிப்பு பற்றி உங்களுக்கு இன்னொரு சிறிய பாடம் கொடுக்க முடிவு செய்தேன்."

உங்களுக்கு ஏற்கனவே தெரியும், ஒரு பொருள் தேவையற்றதாக மாறும்போது ஜாவா இயந்திரம் தன்னைக் கண்காணித்து அதை நீக்குகிறது.

"ஆமாம். நீயும் ரிஷியும் முன்னாடியே சொன்னீங்க. எனக்கு விவரம் ஞாபகம் இல்லை."

"சரி. அப்படின்னா மறுபடியும் போகலாம்."

"ஒரு பொருள் உருவாக்கப்பட்டவுடன், JVM அதற்கு நினைவகத்தை ஒதுக்குகிறது. பொருளின் மீதான ஆர்வம் குறிப்பு மாறிகளைப் பயன்படுத்தி கண்காணிக்கப்படுகிறது.  குப்பை சேகரிப்பின் போது ஒரு பொருளை நீக்கலாம், அதாவது எந்த மாறிகள் இல்லை என்றால் நினைவகம் வெளியிடப்படும் செயல்முறை. பொருள். "

"குப்பை சேகரிப்பாளரைப் பற்றி கொஞ்சம் சொல்லுங்கள் - அது என்ன, அது எப்படி வேலை செய்கிறது."

"சரி. குப்பை சேகரிப்பு மெயின் த்ரெட்டில் நடக்கும். ஒவ்வொரு 5 நிமிடங்களுக்கும் அல்லது அதற்கும் அதிகமாக. எப்போதாவது போதுமான இலவச நினைவகம் இல்லை என்றால், ஜாவா இயந்திரம் அனைத்து த்ரெட்களையும் இடைநிறுத்தி, பயன்படுத்தாத பொருட்களை நீக்கும்."

"ஆனால் இந்த அணுகுமுறை இப்போது கைவிடப்பட்டுள்ளது. அடுத்த தலைமுறை குப்பை சேகரிப்பான் திரைக்குப் பின்னால் மற்றும் ஒரு தனி நூலில் வேலை செய்கிறது. இது ஒரே நேரத்தில் குப்பை சேகரிப்பு என்று அழைக்கப்படுகிறது."

"நான் பார்க்கிறேன். ஒரு பொருளை நீக்குவது அல்லது எடுக்கப்படாதது எப்படி சரியாக முடிவு எடுக்கப்பட்டது?"

"ஒரு பொருளின் குறிப்புகளின் எண்ணிக்கையை எண்ணுவது மிகவும் பயனுள்ளதாக இல்லை - ஒன்றையொன்று குறிப்பிடும் பொருள்கள் இருக்கலாம், ஆனால் வேறு எந்த பொருட்களாலும் குறிப்பிடப்படவில்லை."

"எனவே ஜாவா ஒரு வித்தியாசமான அணுகுமுறையை எடுக்கிறது.  ஜாவா பொருட்களை அடையக்கூடியது மற்றும் அடைய முடியாதது என்று பிரிக்கிறது.  ஒரு பொருள் மற்றொரு அடையக்கூடிய (உயிருள்ள) பொருளால் குறிப்பிடப்பட்டால் அது அடையக்கூடியது (உயிருடன்) , யாரும் அவற்றைக் குறிப்பிடாவிட்டாலும்."

"சரி. எனக்கு புரிந்திருக்கும் என்று நினைக்கிறேன்."

"உண்மையில் குப்பை சேகரிப்பு எப்படி நடக்கிறது - தேவையற்ற பொருட்களை நீக்குவது?"

"இது எளிமையானது. ஜாவாவில், நினைவகம் மாநாடு மூலம் இரண்டு பகுதிகளாக பிரிக்கப்பட்டுள்ளது, மேலும் குப்பை சேகரிக்கும் நேரம் வரும்போது, ​​​​எல்லா உயிருள்ள (அடையக்கூடிய) பொருள்களும் நினைவகத்தின் மற்றொரு பகுதிக்கு நகலெடுக்கப்படுகின்றன, மேலும் பழைய நினைவகம் அனைத்தும் வெளியிடப்படும்."

"இது ஒரு சுவாரஸ்யமான அணுகுமுறை. குறிப்புகளை எண்ண வேண்டிய அவசியமில்லை: அடையக்கூடிய அனைத்து பொருட்களையும் நகலெடுக்கவும், மற்ற அனைத்தும் குப்பை."

"அதை விட இது சற்று சிக்கலானது. பொருள்கள் பொதுவாக இரண்டு வகைகளாகப் பிரிக்கப்படுகின்றன என்பதை ஜாவா புரோகிராமர்கள் கண்டறிந்தனர்: நீண்ட காலம் (நிரல் இயங்கும் முழு நேரமும் இருக்கும்) மற்றும் குறுகிய காலம் (முறைகள் மற்றும் "உள்ளூர் செயல்பாட்டிற்கு இவை தேவை. »செயல்பாடுகள்)."

"நீண்ட காலப் பொருள்களை குறுகிய காலப் பொருட்களிலிருந்து தனித்தனியாக வைத்திருப்பது மிகவும் திறமையானது. இதைச் செய்ய, பொருளின் நீண்ட ஆயுளைக் கண்டறிய ஒரு வழியைக் கொண்டு வருவது அவசியம்."

"எனவே, அவர்கள் அனைத்து நினைவகங்களையும் "தலைமுறைகள்" என்று பிரித்தனர். முதல் தலைமுறை பொருள்கள், இரண்டாம் தலைமுறை பொருள்கள் போன்றவை உள்ளன. ஒவ்வொரு முறையும் நினைவகம் அழிக்கப்படும் போது, ​​தலைமுறை கவுண்டர் 1 ஆல் அதிகரிக்கப்படுகிறது. சில பொருள்கள் பல தலைமுறைகளில் இருந்தால், அவை நீண்ட காலம் வாழ்வதாக பதிவு செய்யப்பட்டுள்ளது."

"இன்று, குப்பை சேகரிப்பான் ஜாவாவின் மிகவும் சிக்கலான மற்றும் திறமையான பகுதியாகும். அதன் பல பாகங்கள் யூகங்களை உருவாக்கும் அல்காரிதம்களின் அடிப்படையில் வியத்தகு முறையில் வேலை செய்கின்றன. இதன் விளைவாக, அது பெரும்பாலும் பயனரின் "கேட்கவில்லை"."

"அர்த்தமா?"

"ஜாவாவில் குப்பை சேகரிப்பான் ( ஜிசி ) பொருள் உள்ளது, அதை System.gc () முறையைப் பயன்படுத்தி அழைக்கலாம் ."

"நீங்கள் System.runFinalization() ஐப் பயன்படுத்தி நீக்கப்பட வேண்டிய பொருட்களின் இறுதி முறைகளுக்கான அழைப்புகளை கட்டாயப்படுத்தலாம். ஆனால் உண்மை என்னவென்றால், ஜாவா ஆவணங்களின்படி, இந்த உத்தரவாதம் குப்பை சேகரிப்பு தொடங்கும் அல்லது இறுதி செய்யாது( ) முறை அழைக்கப்படும்.  குப்பை சேகரிப்பவர் அதை எப்போது அழைக்க வேண்டும், எதில் அழைக்க வேண்டும் என்பதை முடிவு செய்வார் .

"ஐயோ! நல்லா தெரிஞ்சுக்கணும்."

"ஆனால் இன்னும் இருக்கிறது. உங்களுக்குத் தெரியும், ஜாவாவில், சில பொருள்கள் மற்றவற்றைக் குறிப்பிடுகின்றன. ஒரு பொருளை நீக்க வேண்டுமா என்பதைத் தீர்மானிக்க இந்தக் குறிப்புகளின் நெட்வொர்க் பயன்படுத்தப்படுகிறது."

"மற்றும், பாருங்கள். இந்தச் செயல்முறையில் நீங்கள் செல்வாக்கு செலுத்துவதற்கு Java சிறப்புக் குறிப்புகளைக் கொண்டுள்ளது. அவற்றுக்கான சிறப்பு ரேப்பர் வகுப்புகள் உள்ளன. அவை இதோ:"

" மென்மையான குறிப்பு  ஒரு மென்மையான குறிப்பு."

" பலவீனமான குறிப்பு  ஒரு பலவீனமான குறிப்பு."

" பாண்டம் குறிப்பு என்பது ஒரு பாண்டம் குறிப்பு."

"ஓ... இது எனக்கு உள் வகுப்புகள், உள்ளமைக்கப்பட்ட வகுப்புகள், உள்ளமைக்கப்பட்ட அநாமதேய வகுப்புகள் மற்றும் உள்ளூர் வகுப்புகளை நினைவூட்டுகிறது. பெயர்கள் வேறுபட்டவை, ஆனால் அவை எதற்காக என்று தெளிவாகத் தெரியவில்லை."

"சொல்லுங்கள், அமிகோ, நீங்கள் ஒரு ப்ரோக்ராமர் ஆகிவிட்டீர்கள். இப்போது வகுப்புப் பெயர்கள் காரணமாக நீங்கள் கோபமாக இருக்கிறீர்கள், "அவை போதுமான தகவல் இல்லை, மேலும் இந்த வகுப்பு என்ன செய்கிறது, எப்படி என்பதை ஒரே பெயரில் (!) தீர்மானிக்க முடியாது. மேலும் ஏன்"."

"ஐயோ. நான் கவனிக்கவே இல்லை. ஆனால் அது மிகவும் தெளிவாக இருக்கிறது."

"சரி. வார்த்தைகள் போதும். SoftReferences பற்றி சொல்கிறேன்."

"இந்த குறிப்புகள் குறிப்பாக கேச்சிங்கிற்காக வடிவமைக்கப்பட்டுள்ளன, இருப்பினும் அவை மற்ற நோக்கங்களுக்காக பயன்படுத்தப்படலாம் - அனைத்தும் புரோகிராமரின் விருப்பப்படி."

"அத்தகைய குறிப்புக்கான உதாரணம் இங்கே:"

// 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 () முறை திடீரென பூஜ்யமாகத் திரும்பத் தொடங்கும்."

"Clear() முறையை அழைப்பதன் மூலம் பயனர் SoftReference ஐ வெளிப்படையாக அழிக்க முடியும். இந்த வழக்கில், SoftReference பொருளின் உள்ளே உள்ள பலவீனமான இணைப்பு அழிக்கப்படும்."

"இப்பொழுது இத்துடன் நிறைவடைகிறது."

"சுவாரஸ்யமான கதைக்கு நன்றி, எல்லி. இது மிகவும் சுவாரஸ்யமாக இருந்தது."