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

வணக்கம்!

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

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

Cat cat = new Cat(); // Here the lifecycle of our Cat object begins!

முதலில், ஜாவா மெய்நிகர் இயந்திரம் பொருளை உருவாக்க தேவையான அளவு நினைவகத்தை ஒதுக்குகிறது. பின்னர் அது அந்த நினைவகத்திற்கு ஒரு குறிப்பை உருவாக்குகிறது. எங்கள் விஷயத்தில், அந்த குறிப்பு அழைக்கப்படுகிறது cat, எனவே நாம் அதை கண்காணிக்க முடியும். பின்னர் அதன் அனைத்து மாறிகளும் துவக்கப்படும், கன்ஸ்ட்ரக்டர் அழைக்கப்படுகிறது, மற்றும் — ta-da! — நாம் புதிதாகத் தயாரிக்கப்பட்ட பொருள் அதன் சொந்த வாழ்க்கையை வாழ்கிறது :)

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

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(). அதில் ஒரே ஒரு குறிப்பு மட்டுமே இருந்தது, பின்னர் அந்த குறிப்பு சமமாக அமைக்கப்பட்டது null. லம்போர்கினி டையப்லோ பற்றிய குறிப்புகள் எஞ்சியிருப்பதால், ஒதுக்கப்பட்ட நினைவகம் "குப்பை"யாக மாறுகிறது. இது நடக்க ஒரு குறிப்பை பூஜ்யமாக அமைக்க வேண்டியதில்லை:

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. இப்போது Lamborghini Gallardoபொருளுக்கு இரண்டு குறிப்புகள் உள்ளன, ஆனால் Lamborghini Diabloபொருளுக்கு எதுவும் இல்லை. Diabloபொருள் இப்போது குப்பை என்று அர்த்தம் . குப்பை சேகரிப்பான் (GC) எனப்படும் ஜாவாவின் உள்ளமைக்கப்பட்ட பொறிமுறையானது செயல்படும் போது இது.

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

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

குப்பை சேகரிப்பான் ஒரு பொருளை அடையும் போது, ​​அந்த பொருளை அழிப்பதற்கு சற்று முன், அது finalize()பொருளின் மீது ஒரு சிறப்பு முறையை — — அழைக்கிறது. இந்த முறை பொருள் பயன்படுத்தும் பிற ஆதாரங்களை வெளியிடலாம். முறை finalize()வகுப்பின் ஒரு பகுதியாகும் Object. அதாவது நீங்கள் முன்பு சந்தித்த equals(), hashCode()மற்றும் முறைகளுக்கு கூடுதலாக, ஒவ்வொரு பொருளுக்கும் இந்த முறை உள்ளது. toString()இது மற்ற முறைகளிலிருந்து வேறுபடுகிறது - இதை நான் எப்படி வைக்க வேண்டும் - மிகவும் கேப்ரிசியோஸ்.

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

ஆனாலும், உண்மைதான். 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; // This is when the first object becomes available to the garbage collector
       }
   }

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

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

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

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

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

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

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