ஜாவாவில் கார்பேஜ் கலக்சன்.

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

எப்பொழுது ஜாவா கார்பேஜ் கலக்சன் செய்கின்றது?

1.      ஆப்ஜெக்ட் ரீச் ஆகாமல் இருக்கும் பொழுது

BeginnersBook obj = new BeginnersBook(); 

       obj = null;

இங்கு OBJ எனப்படும் ஒரு ஆப்ஜெக்ட் BeginnersBook என்ற கிளாஸிற்கு உருவாக்கினோம். ஆனால் அடுத்த ஸ்டெப்பில் அதற்கு null என்று மதிப்பிருத்துகின்றோம். எனவே அது ரீச் ஆகாமல் இருக்கின்றது. இது பயன்படுத்திய மெமரியை கார்பேஜ் கலக்டர் கிளியர் செய்யும்..
மற்றொரு உதாரணம்

char[] sayhello = { 'h', 'e', 'l', 'l', 'o'};

String str = new String(sayhello);

str = null;

2.ஒரு ஆப்ஜெக்ட் ரெஃபெரென்சை மற்ற ஆப்ஜெக்ட் ரெஃபெரென்ஸிற்கு காப்பி செய்யும் பொழுது

BeginnersBook obj1 = new BeginnersBook();

BeginnersBook obj2 = new BeginnersBook();

obj2 = obj1;

இப்பொழுது obj2  மெமரி அவுட் ஆஃப் ரீச். எனவே  அதை கார்பேஜ் கலக்டர் கிளியர் செய்யும்.

How to request JVM for garbage collection

இது வரை நாம் ஒரு ஆப்ஜெக்ட் அவுட் ஆஃப் யூஸ் ஆகும் போதோ அல்லது அவுட் ஆஃப் ரீச் ஆகும் போதோ கார்பேஜ் கலக்டர் அந்த மெமரியை கிளியர் செய்யும் எனப் பார்த்தோம். எனினும் இது கார்பேஜ் கலக்டர் எப்பொழுது இயங்குகின்றதோ அப்பொழுது தான் நடக்கும். நாம் கார்பேஜ் கலக்டரை explicit ஆக கால் செய்து இயக்கலாம் . அதற்கு System.gc() என்கின்றதோ அதை இயக்க வேண்டும்.

Garbage Collection Example in Java

இந்த நிரலில் ஓவர்ரைட் செய்யப்பட்ட finalize மெதடை எழுதியுள்ளோம். இது கார்பேஜ் கலக்டர் இயங்கும் பொழுது அழைக்கப்படும்.இங்கு System.gc இரண்டு மெமரியை கிளியர் செய்திருப்பதால் இந்த மெத்தட் இரண்டு தடவை அழைக்கப்படுகின்றது.

public class JavaExample{   

   public static void main(String args[]){  

        /* Here we are intentionally assigning a null 

         * value to a reference so that the object becomes

         * non reachable

         */

      JavaExample obj=new JavaExample();  

      obj=null;  

        /* Here we are intentionally assigning reference a 

         * to the another reference b to make the object referenced

         * by b unusable.

         */

      JavaExample a = new JavaExample();

      JavaExample b = new JavaExample();

      b = a;

      System.gc();  

   }  

   protected void finalize() throws Throwable

   {

        System.out.println("Garbage collection is performed by JVM");

   }

}

வெளியீடு:

Garbage collection is performed by JVM

Garbage collection is performed by JVM

நன்றி

முத்து கார்த்திகேயன்,மதுரை.