कचरा संग्रह स्पष्ट रूप से

हाल ही में, मैं जेवीएम विन्यास मुद्दों पर ग्राहकों के साथ काम कर रहा हूं। यह इस तथ्य की तरह दिखता है कि सभी डेवलपर्स और प्रशासकों को पता नहीं है कि कचरा संग्रह कैसे काम करता है और जेवीएम मेमोरी का उपयोग कैसे करता है। इसलिए, मैंने एक स्पष्ट उदाहरण के साथ इस विषय का परिचय देने का फैसला किया। पोस्ट कचरा संग्रह या JVM (यह बहुत बड़ा है) की स्थापना के बारे में ज्ञान की पूरी राशि को कवर करने का नाटक नहीं करता है, और अंत में, वेब पर पहले से ही इस बारे में बहुत कुछ लिखा गया है।



यह पोस्ट हॉटस्पॉट जेवीएम, ओरेकल (पूर्व में सन) से 'रेगुलर' जेवीएम, जेवीएम के बारे में है जिसका आप विंडोज पर सबसे अधिक उपयोग करेंगे। लिनक्स के मामले में, यह एक खुला स्रोत जेवीएम हो सकता है। या तो JVM अन्य सॉफ्टवेयर, जैसे कि WebLogic के साथ आ सकता है, या आप Oracle के Jrockit JVM (पूर्व में BEA) का भी उपयोग कर सकते हैं। या आईबीएम, ऐप्पल आदि से अन्य जेवीएम, इनमें से अधिकांश "अन्य" जेवीएम हॉटस्पॉट के समान तरीके से काम करते हैं, जो जोकित के अपवाद के साथ हैं, जिनके स्मृति प्रबंधन दूसरों से अलग है और जो, उदाहरण के लिए, स्थायी पीढ़ी (नीचे देखें) को समर्पित नहीं करता है।



आइए शुरुआत करें कि जेवीएम मेमोरी का उपयोग कैसे करता है। जेवीएम में, मेमोरी को दो खंडों में विभाजित किया गया है - हीप और स्थायी पीढ़ी। आरेख में, स्थायी पीढ़ी को हरे रंग में दिखाया गया है, शेष ढेर है।

स्थायी पीढ़ी

स्थायी पीढ़ी का उपयोग केवल जेवीएम द्वारा आवश्यक वस्तुओं को संग्रहीत करने के लिए किया जाता है, जिसमें निर्मित वस्तुओं के बारे में मेटाडेटा भी शामिल है। हर बार जब जेवीएम बनाया जाता है, तो यह पीजी में सेट किए गए कुछ डेटा को "डाल" देगा। तदनुसार, जितना अधिक आप विभिन्न प्रकार की वस्तुओं का निर्माण करते हैं, उतना ही पीजी में "रहने की जगह" की आवश्यकता होती है।

PG आकार को दो JVM मापदंडों द्वारा निर्दिष्ट किया जा सकता है: -XX: PermSize - PG का न्यूनतम या प्रारंभिक आकार सेट करता है, और -XX: MaxPermSize - अधिकतम आकार सेट करता है। बड़े जावा अनुप्रयोगों को लॉन्च करते समय, हम अक्सर इन मापदंडों के लिए समान मान सेट करते हैं, इसलिए पीजी को तुरंत "अधिकतम" आकार के साथ बनाया जाता है, जो उत्पादकता बढ़ा सकता है, क्योंकि पीजी आकार बदलना एक महंगा (समय लेने वाला) ऑपरेशन है। इन दो मापदंडों के लिए समान मूल्यों को परिभाषित करने से जेवीएम को अतिरिक्त संचालन करने से बचाया जा सकता है, जैसे कि यह सत्यापित करना कि पीजी को फिर से आकार देने की आवश्यकता है और निश्चित रूप से, सीधे आकार में परिवर्तन किया जाना चाहिए।

ढेर

हीप मुख्य मेमोरी सेगमेंट है जहां आपकी सभी वस्तुएं संग्रहीत होती हैं। हीप को दो उप-खंडों, पुरानी पीढ़ी और नई पीढ़ी में विभाजित किया गया है। नई पीढ़ी, बदले में, ईडन और उत्तरजीवी के दो खंडों में विभाजित है।

ढेर का आकार मापदंडों द्वारा भी निर्दिष्ट किया जा सकता है। आरेख में, ये Xms (न्यूनतम) और -Xmx (अधिकतम) हैं। अतिरिक्त पैरामीटर हीप सेगमेंट के आकार को नियंत्रित करते हैं। हम बाद में उनमें से एक को देखेंगे, बाकी इस पद के दायरे से परे।

ऑब्जेक्ट बनाते समय, जब आप बाइट [] डेटा = नई बाइट [1024] जैसा कुछ लिखते हैं, तो यह ऑब्जेक्ट ईडन खंड में बनाया जाता है। ईडन में नई वस्तुएं बनाई जाती हैं। हमारे बाइट सरणी के लिए वास्तविक डेटा के अलावा, इस डेटा का एक लिंक (पॉइंटर) भी है।

आगे की व्याख्या सरल है। जब आप एक नई वस्तु बनाना चाहते हैं, लेकिन ईडन में अधिक जगह नहीं है, तो जेवीएम एक कचरा संग्रह करता है, जिसका अर्थ है कि जेवीएम उन सभी वस्तुओं की स्मृति में खोज करता है जिनकी अब कोई आवश्यकता नहीं है और उनसे छुटकारा मिल जाता है।



कचरा संग्रह अच्छा है! यदि आपने कभी C या ऑब्जेक्टिव-सी जैसी भाषाओं में प्रोग्राम किया है, तो आप जानते हैं कि मैनुअल मेमोरी मैनेजमेंट एक थकाऊ चीज है और कभी-कभी त्रुटियों का कारण बनता है। JVM होने से स्वचालित रूप से अप्रयुक्त वस्तुओं का ध्यान रखना विकास को आसान बनाता है और डिबगिंग समय को कम करता है। यदि आपने कभी ऐसी भाषाओं में नहीं लिखा है, तो सी लें और एक कार्यक्रम लिखने की कोशिश करें, और महसूस करें कि यह कितना मूल्यवान है कि आपकी भाषा पूरी तरह से नि: शुल्क प्रदान की जाती है।



कई एल्गोरिदम हैं जो जेवीएम का उपयोग कचरा संग्रह करने के लिए कर सकते हैं। आप निर्दिष्ट कर सकते हैं कि जेवीएम द्वारा मापदंडों में से कौन सा उपयोग किया जाएगा।

आइए एक उदाहरण देखें। मान लें कि हमारे पास निम्नलिखित कोड हैं:

String a = "hello"; String b = "apple"; String c = "banana"; String d = "apricot"; String e = "pear"; // //  - // a = null; b = null; c = null; e = null;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ईडन में पांच ऑब्जेक्ट्स ("रखा") बनाए जाते हैं, जैसा कि आरेख में पांच पीले वर्गों द्वारा दिखाया गया है। "कुछ" के बाद, हम लिंक को शून्य करते हुए ए, बी, सी और ई को मुक्त करते हैं। इस बात को ध्यान में रखते हुए कि उनके लिए और अधिक लिंक नहीं हैं, उन्हें अब आवश्यकता नहीं है, और दूसरे आरेख में लाल रंग में दिखाया गया है। हालांकि, हमें अभी भी स्ट्रिंग डी (हरे रंग में दिखाया गया है) की आवश्यकता है।







अगर हम दूसरी वस्तु रखने की कोशिश करते हैं, तो जेवीएम पाएगा कि ईडन भरा हुआ है और उसे साफ करने की जरूरत है। कचरा संग्रह के लिए सरलतम एल्गोरिथ्म को कॉपी संग्रह कहा जाता है, और यह चित्र में दिखाए अनुसार काम करता है। पहले चरण में, मार्क अप्रयुक्त वस्तुओं (लाल) को चिह्नित करता है। दूसरी (प्रतिलिपि) वस्तुओं पर जो अभी भी आवश्यक हैं (डी) उत्तरजीवी खंड में कॉपी की जाती हैं - दाईं ओर का वर्ग। दो सर्वाइवर सेगमेंट हैं, और वे ईडन से छोटे हैं। अब वे सभी वस्तुएँ जिन्हें हम बचाना चाहते हैं, उन्हें उत्तरजीविता में कॉपी किया जाता है, और JVM ईडन से सब कुछ हटा देता है। वह सब है।

यह एल्गोरिथ्म कुछ ऐसा क्षण बनाता है जिसे "जब दुनिया बंद हो जाती है" कहते हैं। जीसी के निष्पादन के दौरान, जेवीएम में अन्य सभी थ्रेड्स को रोक दिया जाता है ताकि हम उनमें से सबकुछ कॉपी करने के बाद उनमें से कोई भी मेमोरी में जाने की कोशिश न करें, जो कि किया गया नुकसान का कारण होगा। यदि यह एक छोटे से अनुप्रयोग में है, तो यह एक बड़ी समस्या नहीं है, लेकिन अगर हमारे पास हाथ पर एक गंभीर कार्यक्रम है, तो कहें, 8-गीगाबाइट के ढेर के साथ, तो जीसी बहुत समय लगेगा - सेकंड या मिनट भी। स्वाभाविक रूप से, एप्लिकेशन को हर बार रोकना एक विकल्प नहीं है। इसलिए, अन्य एल्गोरिदम हैं, और अक्सर उपयोग किए जाते हैं। यदि हमारे पास बहुत सारा कचरा और कुछ उपयोगी वस्तुएं हैं तो कॉपी संग्रह भी अच्छी तरह से काम करता है।

इस पोस्ट में हम दो सामान्य एल्गोरिदम के बारे में बात करेंगे। इच्छुक लोगों के लिए, वेब पर बहुत सारी जानकारी और कुछ अच्छी किताबें हैं।

निम्नलिखित एल्गोरिथ्म को मार्क-स्वीप-कॉम्पैक्ट संग्रह कहा जाता है। एल्गोरिथ्म के तीन चरण हैं:



1) "मार्क": अप्रयुक्त वस्तुएं (लाल) चिह्नित हैं।



2) "स्वीप": इन वस्तुओं को स्मृति से हटा दिया जाता है। आरेख में खाली स्लॉट्स पर ध्यान दें।



3) "कॉम्पैक्ट": वस्तुओं को मुफ्त स्लॉट्स पर कब्जा कर रखा जाता है, जो आपको "बड़ी" ऑब्जेक्ट बनाने की आवश्यकता होने पर अंतरिक्ष को मुक्त करता है।







लेकिन यह सब सिद्धांत है, तो आइए देखें कि यह कैसे काम करता है, उदाहरण के लिए। सौभाग्य से, JDK के पास वास्तविक समय में JVMs की निगरानी के लिए एक दृश्य उपकरण है, जिसका नाम है jvisualvm। यह बिन JDK में स्थित है। हम इसे थोड़ी देर बाद उपयोग करेंगे, पहले हम एप्लिकेशन से निपटेंगे।

विकास, निर्माण और निर्भरता के लिए, मैंने मावेन का उपयोग किया, लेकिन आपको इसकी आवश्यकता नहीं है - यदि आप चाहें तो बस एप्लिकेशन को संकलित करें और चलाएं।

 mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.redstack -DartifactId=memoryTool
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मैंने एक साधारण JAR (98) चुना और बाकी के लिए सब कुछ डिफ़ॉल्ट है। तब मैंने मेमोरीटूल निर्देशिका पर स्विच किया और pom.xml (नीचे, मैंने प्लगइन ब्लॉक जोड़ा) को संपादित किया। इसने मुझे आवश्यक मापदंडों को पारित करते हुए, सीधे मावेन से आवेदन चलाने की अनुमति दी।

 <प्रोजेक्ट xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns: xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi: schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion> 4.0.0 </ modelVersion>
   <groupId> com.redstack </ groupId>
   <विरूपण साक्ष्य> मेमोरीटूल </ विरूपण साक्ष्य>
   <संस्करण> 1.0-SNAPSHOT </ संस्करण>
   <पैकेजिंग> जार </ पैकेजिंग>
   <name> memoryTool </ name>
   <url> http://maven.apache.org </ url>
   <गुण>
     <project.build.sourceEncoding> UTF-8 </project.build.sourceEncoding>
   </ गुण>
   <बिल्ड>
     <प्लगइन्स>
       <प्लगइन>
         <विरूपण साक्ष्य> मावेन-कंपाइलर-प्लगइन </ विरूपण साक्ष्य>
         <संस्करण> 2.0.2 </ संस्करण>
         <विन्यास>
           <स्रोत> 1.6 </ स्रोत>
           <लक्ष्य> 1.6 </ लक्ष्य>
         </ विन्यास>
       </ प्लगइन>
 ---------------------
       <प्लगइन>
         <groupId> org.codehaus.mojo </ groupId>
         <विरूपण साक्ष्य> निष्पादन-मावेन-प्लगइन </ विरूपण साक्ष्य>
         <विन्यास>
           <निष्पादन योग्य> जावा </ निष्पादन योग्य>
           <तर्क>
             <तर्क> -Xms512m </ तर्क>
             <तर्क> -Xmx512m </ तर्क>
             <तर्क> -XX: नया अनुपात = 3 </ तर्क>
             <तर्क> -XX: + PrintGCTimeStamps </ तर्क>
             <तर्क> -XX: + PrintGCDetails </ तर्क>
             <तर्क> -Xloggc: gc.log </ तर्क>
             <तर्क> -क्लासपथ </ तर्क>
             <वर्गपथ />
             <तर्क> com.redstack.App </ तर्क>
           </ तर्क>
         </ विन्यास>
       </ प्लगइन>
 ----------------------
     </ प्लगइन्स>
   </ बिल्ड>
   <निर्भरता>
     <निर्भरता>
       <groupId> junit </ groupId>
       <विरूपण साक्ष्य> कनिष्ठ </ कलाइंद>
       <संस्करण> 3.8.1 </ संस्करण>
       <गुंजाइश> परीक्षण </ गुंजाइश>
     </ निर्भरता>
   </ निर्भरता>
 </ परियोजना>

यदि आप मावेन का उपयोग नहीं करना पसंद करते हैं, तो आप निम्नलिखित कमांड के साथ आवेदन शुरू कर सकते हैं:

 java -Xms512m -Xmx512m -XX:NewRatio=3 -XX:+PrintGCTimeStamps -XX:+PrintGCDetails -Xloggc:gc.log -classpath <whatever> com.redstack.App
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस मामले में:

-Xms 512 एमबी की प्रारंभिक / न्यूनतम हीप आकार निर्धारित करते हैं

-Xmx अधिकतम 512 एमबी का आकार निर्धारित करता है

-एक्सएक्स: नईआरटीओ निर्धारित करता है कि पुरानी पीढ़ी का आकार नई पीढ़ी के आकार से तीन गुना बड़ा है

-XX: + PrintGCTimeStamps, -XX: + PrintGCDetails और -Xloggc: gc.log JVM, gc.log फ़ाइल के लिए कचरा संग्रह के संबंध में अतिरिक्त जानकारी प्रिंट करता है

-क्लासपथ को क्लासपाथ परिभाषित करते हैं

com.redstack.App मुख्य वर्ग



नीचे मुख्य वर्ग के लिए कोड है। एक साधारण प्रोग्राम जिसमें हम ऑब्जेक्ट बनाते हैं और फिर उन्हें फेंक देते हैं, इसलिए यह स्पष्ट है कि मेमोरी का कितना उपयोग किया जाता है और हम देख सकते हैं कि जेवीएम के साथ क्या होता है।

 package com.redstack; import java.io.*; import java.util.*; public class App { private static List objects = new ArrayList(); private static boolean cont = true; private static String input; private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); public static void main(String[] args) throws Exception { System.out.println("Welcome to Memory Tool!"); while (cont) { System.out.println( "\n\nI have " + objects.size() + " objects in use, about " + (objects.size() * 10) + " MB." + "\nWhat would you like me to do?\n" + "1. Create some objects\n" + "2. Remove some objects\n" + "0. Quit"); input = in.readLine(); if ((input != null) && (input.length() >= 1)) { if (input.startsWith("0")) cont = false; if (input.startsWith("1")) createObjects(); if (input.startsWith("2")) removeObjects(); } } System.out.println("Bye!"); } private static void createObjects() { System.out.println("Creating objects..."); for (int i = 0; i < 2; i++) { objects.add(new byte[10*1024*1024]); } } private static void removeObjects() { System.out.println("Removing objects..."); int start = objects.size() - 1; int end = start - 2; for (int i = start; ((i >= 0) && (i > end)); i--) { objects.remove(i); } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कोड बनाने और निष्पादित करने के लिए, निम्न मावेन कमांड का उपयोग करें:

mvan पैकेज निष्पादित: निष्पादन



जैसे ही आप संकलन करते हैं और आगे के कार्यों के लिए तैयार होते हैं, इसे चलाते हैं और jvisualvm करते हैं। यदि आपने पहले jvisualvm का उपयोग नहीं किया है, तो आपको VisualGC प्लगइन स्थापित करने की आवश्यकता है: उपकरण मेनू में प्लगइन्स चुनें, फिर उपलब्ध प्लगइन्स टैब। Visual GC चुनें और इंस्टॉल पर क्लिक करें।

आपको जेवीएम प्रक्रियाओं की एक सूची देखनी चाहिए। उस पर डबल-क्लिक करें जिसमें आपका एप्लिकेशन चल रहा है (इस उदाहरण में com.redstack.App) और विजुअल GC टैब खोलें। नीचे स्क्रीनशॉट में एक जैसा कुछ दिखाई देना चाहिए।







ध्यान दें कि आप स्थायी रूप से स्थायी पीढ़ी, पुरानी पीढ़ी, एडेन और उत्तरजीवी खंडों (एस 0 और एस 1) की स्थिति देख सकते हैं। रंगीन कॉलम उपयोग की गई मेमोरी दिखाते हैं। दाईं ओर एक ऐतिहासिक दृश्य है जो दिखाता है कि कब JVM ने प्रत्येक खंड में कचरा संग्रह और स्मृति की मात्रा का संचालन किया।



एप्लिकेशन विंडो में, ऑब्जेक्ट्स (विकल्प 1) बनाना शुरू करें और देखें कि विज़ुअल जीसी में क्या होता है। कृपया ध्यान दें कि नए ऑब्जेक्ट हमेशा eden में बनाए जाते हैं। अब कुछ वस्तुओं को अनावश्यक बनाएं (विकल्प 2)। आप दृश्य GC में परिवर्तन नहीं देख सकते हैं। ऐसा इसलिए है क्योंकि कचरा संग्रहण प्रक्रिया पूरी होने तक जेवीएम इस स्थान को साफ नहीं करता है।



कचरा संग्रहण आरंभ करने के लिए, ईडन को भरकर अधिक ऑब्जेक्ट बनाएं। भरने के समय क्या होता है, इस पर ध्यान दें। यदि ईडन में बहुत अधिक कचरा है, तो आप देखेंगे कि कैसे ईडन की वस्तुएं उत्तरजीवी से "चलती" हैं। हालांकि, अगर ईडन में थोड़ा कचरा है, तो आप देखेंगे कि पुरानी पीढ़ी में ऑब्जेक्ट कैसे "चाल" करते हैं। ऐसा तब होता है जब जिन वस्तुओं को छोड़ने की आवश्यकता होती है, वे अस्तित्व से अधिक होती हैं।

परमानेंट जेनरेशन में धीरे-धीरे बढ़ोतरी पर भी ध्यान दें।

ईडन में भरने की कोशिश करें, लेकिन अंत तक नहीं, फिर लगभग सभी वस्तुओं को फेंक दें, केवल 20 एमबी छोड़ दें। यह पता चला है कि अधिकांश भाग के लिए ईडन कचरे से भरा हुआ है। उसके बाद, अधिक ऑब्जेक्ट बनाएं। इस बार आप देखेंगे कि ईडन की वस्तुएं सर्वाइवर में जा रही हैं।



अब देखते हैं कि अगर हम स्मृति से बाहर निकलते हैं तो क्या होता है। तब तक ऑब्जेक्ट बनाएं जब तक कि वे 460 एमबी पर न हों। कृपया ध्यान दें कि ईडन और पुरानी पीढ़ी दोनों लगभग पूर्ण हैं। कुछ और ऑब्जेक्ट बनाएँ। जब अधिक मेमोरी नहीं बचती है, तो अनुप्रयोग एक OutOfMemoryException अपवाद के साथ क्रैश हो जाएगा। आप पहले से ही इस व्यवहार का अनुभव कर सकते हैं और सोच सकते हैं कि ऐसा क्यों हुआ - खासकर यदि आपके कंप्यूटर पर बड़ी मात्रा में भौतिक मेमोरी है और आपने सोचा कि यह सब कैसे हो सकता है, कि पर्याप्त मेमोरी नहीं है - अब आप जानते हैं कि क्यों। यदि ऐसा होता है कि स्थायी पीढ़ी भर जाती है (हमारे उदाहरण के मामले में इसे प्राप्त करना कठिन है), तो आप एक और अपवाद बताएंगे कि PermGen भरा हुआ है।



और अंत में, यह देखने का एक और तरीका है कि लॉग में क्या जाना है। यहाँ मेरा एक सा है:

 13.373: [GC 13.373: [ParNew: 96871K-> 11646K (118016K), 0.1215535 सेकंड] 96871K-> 73088K (511232K), 0.1216535 सेकंड] [टाइम्स
 : उपयोगकर्ता = 0.11 sys = 0.07, वास्तविक = 0.12 सेकंड]
 16.267: [GC 16.267: [ParNew: 111290K-> 11461K (118016K), 0.1581621 सेकंड] 172732K-> 166597K (511232K), 0.1582428 सेकंड] [Ti
 मेस: उपयोगकर्ता = 0.16 sys = 0.08, वास्तविक = 0.16 सेकंड]
 19.177: [GC 19.177: [ParNew: 107162K-> 10546K (118016K), 0.1494799 सेकंड] 262297K-> 257845K (511232K), 0.9595659 सेकंड] [Ti
 mes: उपयोगकर्ता = 0.15 sys = 0.07, वास्तविक = 0.15 सेकंड]
 19.331: [जीसी [1 सीएमएस-प्रारंभिक-चिह्न: 247299K (393216K)] 268085K (511232K), 0.0007000 सेकंड] [टाइम्स: उपयोगकर्ता = 0.00 sys = 0.00, वास्तविक
 = 0.00 सेकंड]
 19.332: [CMS-समवर्ती-चिह्न-प्रारंभ]
 19.355: [सीएमएस-समवर्ती-चिह्न: 0.023 / 0.023 सेकंड] [टाइम्स: उपयोगकर्ता = 0.01 sys = 0.01, वास्तविक = 0.02 सेकंड]
 19.355: [सीएमएस-समवर्ती-पूर्व-प्रारंभ]
 19.356: [CMS-समवर्ती-पूर्व: 0.001 / 0.001 सेकंड] [समय: उपयोगकर्ता = 0.00 sys = 0.00, वास्तविक = 0.00 सेकंड]
 19.356: [CMS-समवर्ती-गर्भपात-पूर्व-शुरुआत]
  CMS: समय 24.417 के कारण गर्भपात का शिकार होना: [CMS-समवर्ती-गर्भपात-पूर्वकाल: NAB / 5.061 सेकंड] [Times: user = 0.10 sys =
 0.01, वास्तविक = 5.06 सेकंड]
 24.417: [GC [YG अधिभोग: 23579 K (118016 K)] 24.417: [Rescan (समानांतर), 0.0015049 सेकंड] 24.419: [कमजोर रीफ प्रोसेसिन
 जी, 0.0000064 सेकंड] [1 सीएमएस-टिप्पणी: 247299K (393216K)] 270878K (511232K), 0.0016149 सेकंड] [टाइम्स: उपयोगकर्ता = 0.00 sys = 0.00, फिर से पढ़ें
 l = 0.00 सेकंड]
 24.419: [सीएमएस-समवर्ती-स्वीप-प्रारंभ]
 24.420: [सीएमएस-समवर्ती-स्वीप: 0.001 / 0.001 सेकंड] [टाइम्स: उपयोगकर्ता = 0.00 sys = 0.00, वास्तविक = 0.00 सेकंड]
 24.420: [CMS-समवर्ती-रीसेट-प्रारंभ]
 24.422: [सीएमएस-समवर्ती-रीसेट: 0.002 / 0.002 सेकंड] [टाइम्स: उपयोगकर्ता = 0.00 sys = 0.00, वास्तविक = 0.00 सेकंड]
 24.711: [जीसी [1 सीएमएस-प्रारंभिक-चिह्न: 247298K (393216K)] 291358K (511232K), 0.0017944 सेकंड] [टाइम्स: उपयोगकर्ता = 0.00 sys = 0.00, वास्तविक
 = 0.01 सेकंड]
 24.713: [CMS-समवर्ती-चिह्न-प्रारंभ]
 24.755: [CMS-समवर्ती-चिह्न: 0.040 / 0.043 सेकंड] [समय: उपयोगकर्ता = 0.08 sys = 0.00, वास्तविक = 0.04 सेकंड]
 24.755: [सीएमएस-समवर्ती-पूर्व-प्रारंभ]
 24.756: [CMS-समवर्ती-पूर्व: 0.001 / 0.001 सेकंड] [समय: उपयोगकर्ता = 0.00 sys = 0.00, वास्तविक = 0.00 सेकंड]
 24.756: [सीएमएस-समवर्ती-गर्भपात-पूर्व-शुरुआत]
 25.882: [GC 25.882: [ParNew: 105499K-> 10319K (118016K), 0.1209086 सेकंड] 352798K-> 329314K (511232K), 0.1209042 सेकंड] [Ti
 मेस: उपयोगकर्ता = 0.12 sys = 0.06, वास्तविक = 0.12 सेकंड]
 26.711: [CMS-समवर्ती-गर्भपात-पूर्व: 0.018 / 1.955 सेकंड] [समय: उपयोगकर्ता = 0.22 sys = 0.06, वास्तविक = 1.95 सेकंड]
 26.711: [GC [YG अधिभोग: 72983 K (118016 K)] 26.711: [Rescan (समानांतर), 0.0008802 sec] 26.712: [कमजोर refs processin
 जी, 0.0000046 सेकंड] [1 सीएमएस-टिप्पणी: 318994K (393216K)] 391978K (511232K), 0.0009480 सेकंड] [टाइम्स: उपयोगकर्ता = 0.00 sys = 0.00, फिर से पढ़ें
 l = 0.01 सेकंड]

लॉग में आप देख सकते हैं कि जेवीएम में क्या हुआ - ध्यान दें कि समवर्ती मार्क स्वीप कॉम्पैक्ट संग्रह एल्गोरिथ्म (सीएमएस) का उपयोग किया गया था, इसमें चरणों और वाईजी - यंग जनरेशन का वर्णन है।



आप "उत्पादन" में इन सेटिंग्स का उपयोग कर सकते हैं। यहां तक ​​कि उपकरण भी हैं जो लॉग की कल्पना करते हैं।



खैर, जो कि JVM कचरा संग्रह के सिद्धांत और व्यवहार के बारे में हमारा संक्षिप्त परिचय है। मुझे उम्मीद है कि उदाहरण से आवेदन ने स्पष्ट रूप से यह समझने में मदद की कि जेवीएम में क्या होता है जब आपका आवेदन चल रहा होता है।

रूपेश रामचंद्रन को धन्यवाद कि उन्होंने जेवीएम सेटिंग्स और कचरा संग्रह के बारे में मुझे क्या सिखाया।