பொருளின் வாழ்க்கைச் சுழற்சி

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

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()முக்கியமான ஆதாரங்களை வெளியிடுவதற்கான முறையை நம்ப வேண்டாம்.ஜேவிஎம் அதை அழைக்கலாம் அல்லது அழைக்காமல் இருக்கலாம். யாருக்கு தெரியும்? உங்கள் பொருள் உயிருடன் இருக்கும் போது சில செயல்திறன்-முக்கிய ஆதாரங்களை (உதாரணமாக, திறந்த தரவுத்தள இணைப்பு) வைத்திருந்தால், பொருள் தேவைப்படாதபோது அவற்றை வெளியிட ஒரு சிறப்பு முறையை உருவாக்கி வெளிப்படையாக அழைப்பது நல்லது. அந்த வகையில், உங்கள் நிரலின் செயல்திறன் பாதிக்கப்படாது என்பதை நீங்கள் உறுதியாக அறிவீர்கள். நினைவாற்றலுடன் பணிபுரிவது மற்றும் குப்பை சேகரிப்பு ஆகியவை மிக முக்கியமான தலைப்புகள் என்று சொல்லி ஆரம்பித்தோம், உண்மையில் அவைதான். ஆதாரங்களை தவறாகக் கையாளுதல் மற்றும் தேவையற்ற பொருள்கள் எவ்வாறு சுத்தம் செய்யப்படுகின்றன என்பதை தவறாகப் புரிந்துகொள்வது மிகவும் விரும்பத்தகாத பிழைகளில் ஒன்றுக்கு வழிவகுக்கும்: நினைவக கசிவுகள் . இது மிகவும் பிரபலமான நிரலாக்க பிழைகளில் ஒன்றாகும். இது அதன் சொந்த விக்கிபீடியா கட்டுரையையும் கொண்டுள்ளது. மோசமாக எழுதப்பட்ட குறியீடு ஒவ்வொரு முறையும் புதிதாக உருவாக்கப்பட்ட பொருட்களுக்கு நினைவகம் ஒதுக்கப்படும் சூழ்நிலையை உருவாக்கலாம், ஆனால் பழைய, தேவையற்ற பொருட்கள் குப்பை சேகரிப்புக்கு கிடைக்காது. நாங்கள் ஏற்கனவே ரோபோ வாக்யூம் கிளீனர் ஒப்புமையை உருவாக்கியிருப்பதால், ரோபோவை இயக்குவதற்கு முன், நீங்கள் வீடு முழுவதும் காலுறைகளை சிதறடித்து, கண்ணாடி குவளையை உடைத்து, லெகோ துண்டுகளை தரையில் விட்டால் என்ன நடக்கும் என்று கற்பனை செய்து பாருங்கள். இயற்கையாகவே, ரோபோ ஏதாவது செய்ய முயற்சிக்கும், ஆனால் ஒரு நாள் அது கைப்பற்றும். வெற்றிட கிளீனர் சரியாக இயங்க, நீங்கள் தரையை ஒழுக்கமான வடிவத்தில் வைத்திருக்க வேண்டும் மற்றும் அதை கையாள முடியாத அனைத்தையும் எடுக்க வேண்டும். குப்பை சேகரிப்பாளரும் இதே கொள்கையை பின்பற்றுகிறார். ஒரு நிரலில் சுத்தம் செய்ய முடியாத பல பொருள்கள் இருந்தால் (எங்கள் ரோபோடிக் வெற்றிட கிளீனருக்கான சாக் அல்லது லெகோ போன்றவை), ஒரு நாள் நம் நினைவகம் தீர்ந்துவிடும். உங்கள் நிரல் செயலிழப்பது மட்டுமல்லாமல், கணினியில் இயங்கும் மற்ற எல்லா நிரல்களும் கூட செயலிழக்கும். எல்லாவற்றிற்கும் மேலாக, அவர்களுக்கு போதுமான நினைவகம் இருக்காது (எங்கள் ஒப்புமைக்குத் திரும்புவது, தரையில் உடைந்த கண்ணாடி வெற்றிட கிளீனரை மட்டுமல்ல, வீட்டில் வசிக்கும் மக்களையும் நிறுத்துகிறது). சுருக்கமாக, ஜாவாவில் பொருள் வாழ்க்கைச் சுழற்சி மற்றும் குப்பை சேகரிப்பு இப்படித்தான் இருக்கும். இதை நீங்கள் மனப்பாடம் செய்யத் தேவையில்லை: இது எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொண்டால் போதும். அடுத்த பாடத்தில் நாம் இந்த செயல்முறைகளுக்கு இன்னும் விரிவாகத் திரும்புவேன். ஆனால் இப்போதைக்கு, நீங்கள் கோட்ஜிம் பணிகளைத் தீர்ப்பதற்குத் திரும்பலாம் :) நல்ல அதிர்ஷ்டம்!