वस्तु जीवनचक्र

नमस्ते! मुझे लगता है कि आपको बहुत आश्चर्य नहीं होगा अगर मैंने आपको बताया कि आपके कंप्यूटर में सीमित मात्रा में मेमोरी है :) यहां तक ​​कि आपकी हार्ड ड्राइव (जो रैम के आकार से कई गुना अधिक है) आपके पसंदीदा गेम, टीवी शो और अन्य चीजों से भरी हो सकती है। ऐसा होने से रोकने के लिए, आपको अपने कंप्यूटर की मेमोरी की वर्तमान स्थिति पर नज़र रखनी होगी और अनावश्यक फ़ाइलों को हटाना होगा। यह सब जावा प्रोग्रामिंग से कैसे संबंधित है? बिलकुल सीधे! आखिरकार, कोई भी वस्तु बनाने से जावा मशीन को इसके लिए मेमोरी आवंटित करने का कारण बनता है । एक बड़ा वास्तविक दुनिया कार्यक्रम दसियों या सैकड़ों हजारों वस्तुओं का निर्माण करता है, और उनमें से प्रत्येक के लिए स्मृति का एक हिस्सा आवंटित किया जाता है। लेकिन आपको क्या लगता है, इनमें से कितनी वस्तुओं का अस्तित्व है? क्या हमारा कार्यक्रम चलने के दौरान वे "जीवित" हैं? बिल्कुल नहीं। यहां तक ​​​​कि उनके सभी फायदों के साथ, जावा ऑब्जेक्ट अमर नहीं हैं :) ऑब्जेक्ट्स का अपना जीवन चक्र होता है। आज हम कोड लिखने से थोड़ा ब्रेक लेंगे और इस प्रक्रिया का पता लगाएंगे :) यह समझना भी बहुत महत्वपूर्ण है कि प्रोग्राम कैसे काम करता है और संसाधनों के प्रबंधन के लिए। तो, किसी वस्तु का जीवन कहाँ से शुरू होता है? मनुष्य की तरह, जन्म से, यानी जब इसे बनाया जाता है।

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वस्तु कचरा बन जाती है। यह तब होता है जब जावा का अंतर्निर्मित कचरा कलेक्टर (जीसी) शुरू होता है। कचरा संग्राहक एक आंतरिक जावा तंत्र है जो मेमोरी को मुक्त करने के लिए जिम्मेदार है, अर्थात मेमोरी से अनावश्यक वस्तुओं को हटाना। एक कारण है कि हमने रोबोट वैक्यूम क्लीनर के साथ इसका प्रतिनिधित्व करना क्यों चुना। कचरा संग्राहक लगभग उसी तरह से काम करता है: यह आपके कार्यक्रम को पृष्ठभूमि में "आगे बढ़ता है", कचरा इकट्ठा करता है। आपको व्यावहारिक रूप से इसके साथ बातचीत करने की ज़रूरत नहीं है। इसका काम उन वस्तुओं को हटाना है जो अब प्रोग्राम में उपयोग नहीं की जाती हैं। इस प्रकार, यह अन्य वस्तुओं के लिए मेमोरी को मुक्त करता है। क्या आपको याद है कि पाठ की शुरुआत में हमने वास्तविक जीवन में कहा था कि आपको अपने कंप्यूटर की स्थिति की निगरानी करनी है और पुरानी फाइलों को हटाना है? अगर हम जावा ऑब्जेक्ट्स के बारे में बात कर रहे हैं, कचरा कलेक्टर आपके लिए यह करता है. जब आपका प्रोग्राम चलता है तो कचरा संग्राहक कई बार शुरू होता है: आपको इसे स्पष्ट रूप से कॉल करने और इसे आदेश देने की ज़रूरत नहीं है (हालांकि यह तकनीकी रूप से संभव है)। हम बाद में कचरा कलेक्टर के बारे में और बात करेंगे और विश्लेषण करेंगे कि यह कैसे काम करता है। जब कचरा संग्राहक किसी वस्तु तक पहुँचता है - उसके नष्ट होने से ठीक पहले - वस्तु की विशेष 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()महत्वपूर्ण संसाधनों को जारी करने के तरीके पर भरोसा न करें।जेवीएम इसे बुला सकता है, या शायद नहीं। कौन जानता है? यदि आपके ऑब्जेक्ट में जीवित रहते हुए कुछ प्रदर्शन-महत्वपूर्ण संसाधन (उदाहरण के लिए, एक खुला डेटाबेस कनेक्शन) था, तो ऑब्जेक्ट की आवश्यकता नहीं होने पर उन्हें रिलीज़ करने के लिए एक विशेष विधि बनाना और स्पष्ट रूप से कॉल करना बेहतर होगा। इस तरह, आपको निश्चित रूप से पता चल जाएगा कि आपके कार्यक्रम के प्रदर्शन पर कोई असर नहीं पड़ेगा। हमने यह कहकर शुरू किया कि स्मृति और कचरा संग्रहण के साथ काम करना बहुत महत्वपूर्ण विषय हैं और वास्तव में वे हैं। संसाधनों को गलत तरीके से संभालने और अनावश्यक वस्तुओं को कैसे साफ किया जाता है, इसकी गलतफहमी सबसे अप्रिय बगों में से एक को जन्म दे सकती है: मेमोरी लीक । यह सबसे प्रसिद्ध प्रोग्रामिंग त्रुटियों में से एक है। इसका अपना विकिपीडिया लेख भी है. खराब लिखित कोड एक ऐसी स्थिति पैदा कर सकता है जहां नई बनाई गई वस्तुओं के लिए हर बार मेमोरी आवंटित की जाती है, लेकिन पुरानी, ​​​​अनावश्यक वस्तुएं कचरा संग्रह के लिए अनुपलब्ध होती हैं। चूंकि हमने पहले ही रोबोट वैक्यूम क्लीनर सादृश्य बना लिया है, कल्पना करें कि क्या होगा यदि रोबोट को चलाने से पहले आप पूरे घर में मोज़े बिखेर दें, एक कांच के फूलदान को तोड़ दें, और लेगो के टुकड़े पूरे फर्श पर छोड़ दें। स्वाभाविक रूप से, रोबोट कुछ करने की कोशिश करेगा, लेकिन एक दिन वह जब्त कर लेगा। वैक्यूम क्लीनर के ठीक से चलने के लिए, आपको फर्श को उचित आकार में रखना होगा और वह सब कुछ उठाना होगा जिसे वह संभाल नहीं सकता है। कचरा संग्रहकर्ता उसी सिद्धांत का पालन करता है। यदि किसी प्रोग्राम में बहुत सी वस्तुएं हैं जिन्हें वह साफ नहीं कर सकता है (जैसे हमारे रोबोटिक वैक्यूम क्लीनर के लिए एक जुर्राब या लेगो), तो एक दिन हम स्मृति से बाहर हो जाएंगे। न केवल आपका प्रोग्राम हैंग हो जाएगा, बल्कि कंप्यूटर पर चल रहे अन्य सभी प्रोग्राम भी हैंग हो जाएंगे। आखिरकार, उनके पास पर्याप्त मेमोरी भी नहीं होगी (हमारी सादृश्यता पर लौटते हुए, फर्श पर टूटा हुआ कांच न केवल वैक्यूम क्लीनर, बल्कि घर में रहने वाले लोगों को भी रोकता है)। संक्षेप में, यह जावा में वस्तु जीवनचक्र और कचरा संग्रह जैसा दिखता है। आपको इसे याद रखने की आवश्यकता नहीं है: यह समझने के लिए पर्याप्त है कि यह कैसे काम करता है। अगले पाठ में, हम इन प्रक्रियाओं पर अधिक विस्तार से लौटूंगा। लेकिन अभी के लिए, आप CodeGym कार्यों को हल करने के लिए वापस आ सकते हैं :) शुभकामनाएँ!