Object resurrection
குப்பை சேகரிப்புடன் கூடிய பொருள் சார்ந்த நிரலாக்க மொழிகளில், பொருள் உயிர்த்தெழுதல் என்பது பொருள் அழிவு செயல்முறையின் போது ஒரு பொருள் மீண்டும் உயிர்ப்பிக்கும் போது, ஒரு இறுதி செய்பவர் செயல்படுத்தப்படுவதன் பக்க விளைவு ஆகும். பொருள் உயிர்த்தெழுதல் பல சிக்கல்களை ஏற்படுத்துகிறது, குறிப்பாக பொருள் உயிர்த்தெழுதலுக்கான சாத்தியம்-அது நடக்காவிட்டாலும் கூட-குப்பை சேகரிப்பை கணிசமாக மிகவும் சிக்கலானது மற்றும் மெதுவாக ஆக்குகிறது, மேலும் இறுதி செய்பவர்கள் ஊக்கப்படுத்தப்படுவதற்கு இது ஒரு முக்கிய காரணமாகும். மொழிகள் பொருள் உயிர்த்தெழுதலை பல்வேறு வழிகளில் கையாள்கின்றன. அரிதான சூழ்நிலைகளில், சில வடிவமைப்பு வடிவங்களை செயல்படுத்த பொருள் உயிர்த்தெழுதல் பயன்படுத்தப்படுகிறது, குறிப்பாக ஒரு பொருள் குளம், மற்ற சூழ்நிலைகளில் உயிர்த்தெழுதல் என்பது இறுதிப் பிழையால் ஏற்படும் விரும்பத்தகாத பிழையாகும், மேலும் பொதுவாக உயிர்த்தெழுதல் ஊக்கமளிக்கப்படுகிறது. செயல்முறை பொருள் உயிர்த்தெழுதல் பின்வரும் செயல்முறையின் மூலம் நிகழ்கிறது. முதலாவதாக, ஒரு பொருள் நிரலில் இருந்து இனி அணுக முடியாதபோது குப்பையாக மாறுகிறது, மேலும் சேகரிக்கப்படலாம் (அழிக்கப்பட்டு ஒதுக்கப்படலாம்). பின்னர், பொருளை அழிக்கும் போது, குப்பை சேகரிப்பாளர் பொருளை ஒதுக்குவதற்கு முன்பு, ஒரு ஃபைனலைசர் முறையை இயக்கலாம், இது அந்த பொருளை அல்லது மற்றொரு குப்பை பொருளை (ஃபைனலைசருடன் பொருளிலிருந்து அடையக்கூடியது) குறிப்புகளை உருவாக்குவதன் மூலம் மீண்டும் அடையக்கூடியதாக இருக்கும், ஏனெனில் ஒரு ஃபைனலைசரில் தன்னிச்சையான குறியீடு இருக்கலாம். இது நடந்தால், குறிப்பிடப்பட்ட பொருள்-இது இறுதி செய்யப்பட்ட பொருள் அல்ல-இனி குப்பை அல்ல, மேலும் அதை ஒதுக்கி வைக்க முடியாது, இல்லையெனில் அதைப் பற்றிய குறிப்புகள் தொங்கும் குறிப்புகளாக மாறும் மற்றும் பயன்படுத்தும்போது பிழைகளை ஏற்படுத்தும், பொதுவாக நிரல் செயலிழப்பு அல்லது கணிக்க முடியாத நடத்தை. அதற்கு பதிலாக, நினைவக பாதுகாப்பைப் பராமரிப்பதற்காக, பொருள் உயிர்ப்பிக்கப்படுகிறது அல்லது உயிர்த்தெழுப்பப்படுகிறது. இதைக் கண்டறிவதற்காக, ஒரு குப்பை சேகரிப்பாளர் பொதுவாக இறுதி செய்பவர்களின் முன்னிலையில் இரண்டு கட்ட சேகரிப்பைச் செய்வார்ஃ முதலில் ஒரு இறுதி செய்பவரைக் கொண்ட எந்தவொரு குப்பையையும் இறுதி செய்யுங்கள், பின்னர் அனைத்து குப்பைகளையும் (அல்லது இறுதி செய்பவர்களுடன் கூடிய பொருட்களிலிருந்து அடையக்கூடிய அனைத்து குப்பைகளையும்) மீண்டும் சரிபார்க்கவும், இறுதி செய்பவர்கள் சில குப்பைகளை மீண்டும் எழுப்பியிருந்தால். இது மேல்நோக்கி சேர்க்கிறது மற்றும் நினைவக மீட்டெடுப்பை தாமதப்படுத்துகிறது. உயிர்த்தெழுந்த பொருள் மற்ற பொருட்களைப் போலவே நடத்தப்படலாம் அல்லது விசேஷமாக நடத்தப்படலாம். பல மொழிகளில், குறிப்பாக சி #, ஜாவா மற்றும் பைதான் (பைதான் 3.4 இலிருந்து), பொருள்கள் ஒரு முறை மட்டுமே இறுதி செய்யப்படுகின்றன, ஒரு பொருள் மீண்டும் மீண்டும் உயிர்த்தெழுப்பப்படுவதையோ அழிக்க முடியாததாகவோ இருப்பதையோ தவிர்க்க; சி #இல் இயல்பாகவே இறுதி செய்பவர்களுடன் கூடிய பொருள்கள் ஒரு முறை மட்டுமே இறுதி செய்யப்படுகின்றன, ஆனால் இறுதி செய்வதற்கு மீண்டும் பதிவு செய்யலாம். மற்ற சந்தர்ப்பங்களில் உயிர்த்தெழுப்பப்பட்ட பொருள்கள் பிழைகளாக கருதப்படுகின்றன, குறிப்பாக குறிக்கோள்-சி இல்; அல்லது பிற பொருட்களுக்கு ஒரே மாதிரியாக நடத்தப்படுகின்றன, குறிப்பாக பைத்தானுக்கு முன்பு பைத்தானில். உயிர்த்தெழுப்பப்பட்ட ஒரு பொருள் சில நேரங்களில் ஒரு அல்லது ஜோம்பி என்று அழைக்கப்படுகிறது, ஆனால் இந்த சொல் பொருள் அழிவு தொடர்பான பல்வேறு பொருள் நிலைகளுக்கு பயன்படுத்தப்படுகிறது, பயன்பாடு மொழி மற்றும் ஆசிரியரைப் பொறுத்தது. ஒரு "ஜோம்பி பொருள்" என்பது குறிக்கோள்-சி இல் ஒரு சிறப்பு பொருளைக் கொண்டுள்ளது, இருப்பினும், இது கீழே விவரிக்கப்பட்டுள்ளது. ஜோம்பி பொருள்கள் ஜோம்பி செயல்முறைகளுக்கு ஓரளவு ஒத்தவை, அதில் அவை ஒரு முடித்தல் நிலை மாற்றத்திற்கு உட்பட்டுள்ளன மற்றும் இடமாற்றத்திற்கு நெருக்கமாக உள்ளன, ஆனால் விவரங்கள் கணிசமாக வேறுபட்டவை. . NET கட்டமைப்பில் உள்ள மாறுபாடுகள், குறிப்பாக C #மற்றும் VB.NET, "பொருள் உயிர்த்தெழுதல்" என்பது இறுதி செய்யும் போது ஒரு பொருளின் நிலையை குறிக்கிறதுஃ பொருள் மீண்டும் உயிர்ப்பிக்கப்படுகிறது (அணுக முடியாததிலிருந்து), இறுதி செய்பவர் இயக்கப்படுகிறார், பின்னர் அணுக முடியாத நிலைக்குத் திரும்புகிறார் (மேலும் எதிர்கால இறுதிப்படுத்தலுக்காக இனி பதிவு செய்யப்படவில்லை). . NET இல், எந்தப் பொருள்களை இறுதி செய்ய வேண்டும் என்பது பொருளுக்கு பொருள் கண்காணிக்கப்படுவதில்லை, மாறாக ஒரு இறுதி "வரிசையில்" சேமிக்கப்படுகிறது, எனவே இந்த கட்டுரையின் அர்த்தத்தில் உயிர்த்தெழுப்பப்பட்ட பொருள்களின் கருத்தை விட, ஒருவர் "இறுதி செய்ய வரிசையில்" உள்ள பொருள்களைப் பற்றி பேசுகிறார். மேலும், என்க்யூ பொருள்களை பெருக்காமல் பார்த்துக் கொண்டு, GC.ReRegisterForFinalize வழியாக இறுதியாக்கத்திற்காக பொருட்களை மீண்டும் என்க்யூ செய்ய முடியும். ஒரு பொருள் தன்னை அல்லது மற்றொரு பொருளை மீண்டும் உயிர்ப்பிக்க இரண்டு முக்கிய வழிகள் உள்ளனஃ அது அடையக்கூடிய ஒரு பொருளில் தன்னைப் பற்றிய குறிப்பை உருவாக்குவதன் மூலம் (குப்பை அடைய முடியாது, ஆனால் குப்பை குப்பை அல்லாத பொருட்களைக் குறிக்கலாம்), அல்லது சூழலில் ஒரு குறிப்பை உருவாக்குவதன் மூலம் (உலகளாவிய மாறிகள், அல்லது சில சந்தர்ப்பங்களில் நிலையான மாறிகள் அல்லது மூடுதலில் மாறிகள்). ஒரு பொருள் தன்னை உயிர்த்தெழுப்புவதற்கு, இரண்டிற்கும் பைதான் எடுத்துக்காட்டுகள் பின்பற்றப்படுகின்றன. கொடுக்கப்பட்ட குப்பை சேகரிப்பு சுழற்சியில், ஒரே வழிமுறைகளால் சேகரிக்கப்பட்டால், ஒரு பொருள் மற்ற பொருட்களை உயிர்த்தெழுப்பவும் முடியும். அது அடையக்கூடிய ஒரு பொருளில் ஒரு குறிப்பை உருவாக்குவதன் மூலம் தன்னை மீட்டெடுக்கிறதுஃ வகுப்பு கிளிங்கிஃ டிஃப் _ _ init _ (சுய, ரிஃப் = எதுவும் இல்லை)-> எதுவுமில்லைஃ self.ref = ரிஃப் டிஃப் _ _ டெல் _ (சுய): என்றால் self.ref: self.ref. ரிஃப் = சுய அச்சு ("என்னை விட்டு வெளியேற வேண்டாம்!") a = கிளிங்கி (கிளிங்கி ()) #ஒரு 2-உறுப்பு இணைக்கப்பட்ட பட்டியலை உருவாக்குங்கள், #|a | a.ref ஆல் குறிப்பிடப்படுகிறது. ரீஃப் = a #ஒரு சுழற்சியை உருவாக்குங்கள் a.ref = எதுவும் இல்லை #முதல் முனையிலிருந்து இரண்டாவது குறிப்பை அகற்றுவது இரண்டாவது குப்பையை a.ref = எதுவும் இல்லை உலகளாவிய சூழலில் ஒரு குறிப்பை உருவாக்குவதன் மூலம் தன்னை மீட்டெடுக்கிறதுஃ c = எதுவும் இல்லை வகுப்பு அழியாததுஃ டெஃப் _ _ டெல் _ (சுய): உலகளாவிய cc = சுய அச்சு ("நான் இன்னும் இறக்கவில்லை"). மேலே உள்ள எடுத்துக்காட்டுகளில், CPython இல் 3.4 க்கு முன், இவை மீண்டும் மீண்டும் இறுதி செய்பவர்களை இயக்கும், மேலும் பொருள்கள் குப்பை சேகரிக்கப்படாது, அதே நேரத்தில் CPython 3.4 மற்றும் அதற்குப் பிறகு, இறுதி செய்பவர்கள் ஒரு முறை மட்டுமே அழைக்கப்படுவார்கள், மேலும் பொருட்கள் இரண்டாவது முறையாக அணுக முடியாதபோது குப்பை சேகரிக்கப்படும். சிக்கல்கள் பொருள் உயிர்த்தெழுதல் ஏராளமான சிக்கல்களை ஏற்படுத்துகிறது. குப்பை சேகரிப்பை சிக்கலாக்குகிறது பொருள் உயிர்த்தெழுதலுக்கான சாத்தியம் என்பது குப்பை சேகரிப்பாளர் இறுதி செய்யப்பட்ட பிறகு உயிர்த்தெழுப்பப்பட்ட பொருட்களை சரிபார்க்க வேண்டும்-அது உண்மையில் நடக்காவிட்டாலும் கூட-இது குப்பை சேகரிப்பை சிக்கலாக்குகிறது மற்றும் குறைக்கிறது. அழிக்க முடியாத பொருள்கள் சில சூழ்நிலைகளில் ஒரு பொருள் அழிக்க முடியாததாக இருக்கலாம்ஃ ஒரு பொருள் அதன் சொந்த ஃபைனலைசரில் உயிர்த்தெழுப்பப்பட்டால் (அல்லது பொருட்களின் குழு அவற்றின் ஃபைனலைசர்களின் விளைவாக ஒருவருக்கொருவர் உயிர்த்தெழுந்தால்), மற்றும் ஃபைனலைசர் எப்போதும் பொருளை அழிக்கும் போது அழைக்கப்படுகிறது, பின்னர் பொருளை அழிக்க முடியாது மற்றும் அதன் நினைவகத்தை மீட்டெடுக்க முடியாது. தற்செயலான உயிர்த்தெழுதல் மற்றும் கசிவுகள் மூன்றாவதாக, பொருள் உயிர்த்தெழுதல் தற்செயலாக இருக்கலாம், இதன் விளைவாக வரும் பொருள் சொற்பொருள் குப்பையாக இருக்கலாம், எனவே உண்மையில் ஒருபோதும் சேகரிக்கப்படுவதில்லை, இதனால் தர்க்கரீதியான நினைவக கசிவு ஏற்படுகிறது. சீரற்ற நிலை மற்றும் மறு துவக்கம் ஒரு உயிர்த்தெழுந்த பொருள் சீரற்ற நிலையில் இருக்கலாம், அல்லது வகுப்பு மாறிலிகளை மீறலாம், ஏனெனில் இறுதி செய்பவர் செயல்படுத்தப்பட்டு ஒழுங்கற்ற நிலையை ஏற்படுத்துகிறது. எனவே உயிர்த்தெழுப்பப்பட்ட பொருள்கள் பொதுவாக கைமுறையாக மீண்டும் தொடங்கப்பட வேண்டும். தனித்துவமான இறுதிப்படுத்தல் அல்லது மறு இறுதிப்படுத்தல் சில மொழிகளில் (ஜாவா மற்றும் பைதான் போன்ற) இறுதிப்படுத்தல் ஒரு பொருளுக்கு ஒரு முறை சரியாக நடக்கும் என்று உத்தரவாதம் அளிக்கப்படுகிறது, எனவே உயிர்த்தெழுப்பப்பட்ட பொருள்கள் அவற்றின் இறுதிப்படுத்திகளை அழைக்காது; எனவே, உயிர்த்தெழுப்பப்பட்ட பொருள்கள் இறுதிப்படுத்தலுக்கு வெளியே தேவையான சுத்தம் குறியீட்டை செயல்படுத்த வேண்டும். வேறு சில மொழிகளில், புரோகிராமர் இறுதியாக்கத்தை மீண்டும் மீண்டும் செய்ய கட்டாயப்படுத்தலாம்; குறிப்பாக, சி #க்கு GC.ReRegisterForFinalize உள்ளது. தீர்வுகள் பொருள் உயிர்த்தெழுதலைச் சமாளிப்பதற்கான பல்வேறு முறைகளை மொழிகள் ஏற்றுக்கொண்டுள்ளன, பொதுவாக இறுதி செய்பவர்களின் முன்னிலையில் இரண்டு கட்ட குப்பை சேகரிப்பை மேற்கொள்வதன் மூலம், தொங்கும் குறிப்புகளைத் தடுக்க; மற்றும் பொருட்களை ஒரு முறை மட்டுமே இறுதி செய்வதன் மூலம், குறிப்பாக பொருட்களை இறுதி செய்யப்பட்டதாகக் குறிப்பதன் மூலம் (ஒரு கொடி வழியாக), பொருட்களை அழிக்க முடியும் என்பதை உறுதிப்படுத்த. பொருள் மீண்டும் அணுக முடியாதது என்பதை நிரூபிக்கும் வரை ஜாவா பொருளை விடுவிக்காது, ஆனால் இறுதிப் பொருளை ஒன்றுக்கு மேற்பட்ட முறை இயக்காது. பைத்தானில், பைதான் 3.4 க்கு முன்பு, நிலையான CPython செயல்படுத்தல் உயிர்த்தெழுப்பப்பட்ட பொருள்களை மற்ற பொருட்களுடன் (ஒருபோதும் இறுதி செய்யப்படாதவை) ஒரே மாதிரியாகக் கையாளும், இதனால் அழிக்க முடியாத பொருள்கள் சாத்தியமாகும். மேலும், பொருள் உயிர்த்தெழுதலில் சாத்தியமான சிக்கல்களைத் தவிர்ப்பதற்காக, இறுதிப் பொருளுடன் ஒரு பொருளைக் கொண்ட சுழற்சிகளை அது குப்பை சேகரிக்காது. பைதான் 3.4 இல் தொடங்கி, நடத்தை பெரும்பாலும் ஜாவாவைப் போலவே உள்ளதுஃ பொருள்கள் ஒரு முறை மட்டுமே இறுதி செய்யப்படுகின்றன ("ஏற்கனவே இறுதி செய்யப்பட்டவை" என்று குறிக்கப்படுகின்றன), சுழற்சிகளின் குப்பை சேகரிப்பு இரண்டு கட்டங்களாக உள்ளது, இரண்டாவது கட்டம் உயிர்த்தெழுப்பப்பட்ட பொருள்களைச் சரிபார்க்கிறது. குறிக்கோள்-சி 2 உயிர்த்தெழுந்த பொருட்களை "ஜோம்பி" நிலையில் வைக்கும், அங்கு அவர்கள் அனுப்பப்பட்ட அனைத்து செய்திகளையும் பதிவு செய்கிறார்கள், ஆனால் வேறு எதுவும் செய்ய மாட்டார்கள். மேலும் காண்க தானியங்கி குறிப்பு எண்ணிக்கைஃ பலவீனமான குறிப்புகளைக் கையாள்வதற்கான பலவீனமான குறிப்புகளை பூஜ்ஜியப்படுத்துதல். . NET கட்டமைப்பில், குறிப்பாக C #மற்றும் VB.NET, பொருள் இறுதிப்படுத்தல் ஒரு இறுதிப்படுத்தல் "வரிசை" மூலம் தீர்மானிக்கப்படுகிறது, இது பொருள் அழிவின் போது சரிபார்க்கப்படுகிறது. ஒரு ஃபைனலைசர் கொண்ட பொருள்கள் உருவாக்கத்தின் போது இந்த வரிசையில் வைக்கப்பட்டு, ஃபைனலைசர் அழைக்கப்படும்போது டெக்யூ செய்யப்படலாம், ஆனால் மேனுவலாக டெக்யூ செய்யப்படலாம் (ஃபைனலைஸ் செய்வதற்கு முன்பு) சப்ரெஸ் ஃபைனலைஸ் அல்லது ரீ ரெஜிஸ்டர் ஃபார் ஃபைனலைஸ் மூலம் ரீ-என்க்யூ செய்யப்படலாம். எனவே முன்னிருப்பாக ஃபைனலைசர்களுடன் கூடிய பொருள்கள் அதிகபட்சமாக ஒரு முறை இறுதி செய்யப்படுகின்றன, ஆனால் இந்த ஃபைனலைசேஷன் அடக்கப்படலாம், அல்லது பொருள்கள் உயிர்த்தெழுப்பப்பட்டு (மீண்டும் அணுகக்கூடியதாக) பின்னர் ஃபைனலைசேஷனுக்காக மீண்டும் இணைக்கப்பட்டால் பல முறை ஃபைனலைஸ் செய்யப்படலாம். மேலும், பலவீனமான குறிப்புகள் இயல்பாகவே உயிர்த்தெழுதலைக் கண்காணிக்காது, அதாவது ஒரு பொருள் உயிர்த்தெழுந்தால் பலவீனமான குறிப்பு புதுப்பிக்கப்படாது; இவை குறுகிய பலவீனமான குறிப்புகள் என்றும், உயிர்த்தெழுதலைக் கண்காணிக்கும் பலவீனமான குறிப்புகள் நீண்ட பலவீனமான குறிப்புகள் என்றும் அழைக்கப்படுகின்றன. பயன்பாடுகள் பொருள் உயிர்த்தெழுதல் பொதுவாகப் பயன்படுத்தப்படும் பொருட்களின் பொருள் தொகுப்பைக் கையாள பயனுள்ளதாக இருக்கும், ஆனால் இது குறியீட்டை மறைத்து மேலும் குழப்பமடையச் செய்கிறது. அடிக்கடி பயன்படுத்தக்கூடிய பொருட்களுக்கும், அதன் கட்டுமானம்/அழிவு நேரம் எடுக்கும் இடங்களுக்கும் மட்டுமே இது பயன்படுத்தப்பட வேண்டும். ஒரு எடுத்துக்காட்டு சீரற்ற எண்களின் வரிசையாக இருக்கலாம், அங்கு அவற்றில் ஒரு பெரிய எண்ணிக்கை குறுகிய காலத்தில் உருவாக்கப்பட்டு அழிக்கப்படுகிறது, ஆனால் உண்மையில் ஒரே நேரத்தில் ஒரு சிறிய எண் மட்டுமே பயன்பாட்டில் உள்ளது. பொருள் உயிர்த்தெழுதலுடன், ஒரு பூலிங் நுட்பம் உருவாக்கம் மற்றும் அழிவின் தேவையற்ற மேல்நிலையைக் குறைக்கும். இங்கே, ஒரு பூல் மேலாளர் அதன் பொருள் அடுக்கு தகவலை பொருளைப் பற்றிய குறிப்பு வடிவத்தில் பெறுவார், அது தற்போது அழிக்கப்பட வேண்டும் என்றால். பூல் மேலாளர் பின்னர் மறுபயன்பாட்டிற்காக பொருளை வைத்திருப்பார். மேலும் காண்க பொருள் வாழ்நாள் குறிப்புகள் குறிப்புகள் நினைவக மேலாண்மை பொருள் (கணினி அறிவியல்)