अंतिम रूप दें और अंतिम रूप दें

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

अंतिम रूप के लिए आधिकारिक दस्तावेज () निम्नलिखित कहता है:

कचरा संग्रहकर्ता द्वारा किसी वस्तु पर तब कॉल किया जाता है जब कचरा संग्रह यह निर्धारित करता है कि वस्तु के लिए अधिक संदर्भ नहीं हैं।

इससे, हम मान सकते हैं कि "जमे हुए" अंतिम रूप () कचरा संग्रहकर्ता धागे को निलंबित कर देगा और निर्माण बंद हो जाएगा। दरअसल (कम से कम हॉटस्पॉट 1.6 में) कचरा संग्रहकर्ता सीधे अंतिम रूप () विधियों को कॉल नहीं करता है, लेकिन केवल स्थिर विधि java.lang.ref.Finalizer.register (ऑब्जेक्ट) को कॉल करके संबंधित सूची में विशिष्ट वस्तुओं को जोड़ता है। फ़ाइनलीज़र क्लास का ऑब्जेक्ट उस ऑब्जेक्ट का संदर्भ है जिसके लिए अंतिम रूप दिया जाना चाहिए (), और अगले और पिछले फ़ाइनलीज़र के लिंक को संग्रहीत करता है, जो एक दोगुनी लिंक की गई सूची बनाता है।

अंतिम रूप () कॉल को एक अलग स्ट्रीम "फाइनल" (java.lang.ref.Finalizer.FinalizerThread) में सीधे किया जाता है, जो तब बनाया जाता है जब वर्चुअल मशीन शुरू होती है (फाइनल क्लास को लोड करते समय स्टैटिक सेक्शन में अधिक सटीक रूप से)। अंतिम रूप () विधियों को क्रमिक रूप से उस क्रम में कहा जाता है, जिसमें वे कचरा संग्रहकर्ता द्वारा सूची में जोड़े गए थे। तदनुसार, यदि कुछ अंतिम रूप () हैंग हो जाता है, तो यह फ़ाइनलीज़र थ्रेड लटकाएगा, लेकिन कचरा संग्रहकर्ता नहीं। विशेष रूप से, इसका मतलब यह है कि जिन वस्तुओं में अंतिम रूप () विधि ठीक नहीं है, उन्हें हटा दिया जाएगा, लेकिन वे जो कतार में जोड़े जाते हैं जब तक कि फ़ाइनलीज़र थ्रेड लटका नहीं जाता, अनुप्रयोग समाप्त हो जाता है, या स्मृति समाप्त हो जाती है।

हम इसका उदाहरण देते हैं। आइए एक ऐसा वर्ग बनाएं जिसकी वस्तुएँ ढेर पर शालीनता से खाती हैं:

static class BigObject { char[] tmp = new char[10000]; } 

और इस मुख्य विधि की तरह कुछ लिखें:

  public static void main(String... args) { int i=0; while(true) { new BigObject(); try { Thread.sleep(10); } catch( InterruptedException e ) {} if(i++%100==0) System.out.println("Total: "+Runtime.getRuntime().totalMemory()+ "; free: "+Runtime.getRuntime().freeMemory()); } } 

हम प्रत्येक पुनरावृत्ति पर एक वस्तु बनाते हैं, और एक बार एक सौ पुनरावृत्तियों में हम शेष मेमोरी के बारे में जानकारी प्रदर्शित करते हैं। हम जावा मशीन की मेमोरी को सीमित करेंगे ताकि परीक्षणों में देरी न हो और परिणाम देखें:
$ java -Xms16m -Xmx16m Test
Total: 16252928; free: 15965064
Total: 16252928; free: 14013136
Total: 16252928; free: 12011536
Total: 16252928; free: 14309664
Total: 16252928; free: 12308064
Total: 16252928; free: 14797440
Total: 16252928; free: 12795840
Total: 16252928; free: 15307784
...

मेमोरी को ठीक से आवंटित और मुक्त किया गया है।

अब एक ऐसा वर्ग बनाएं जिसकी वस्तुएँ बहुत समय से अंतिम रूप दे रही हैं ():

  static class LongFinalize { protected void finalize() throws Throwable { System.out.println("LongFinalize finalizer"); Thread.sleep(10000000); } } 

लूप से पहले नए LongFinalize () को मुख्य () में जोड़ें। परिणाम इस प्रकार होगा:
$ java -Xms16m -Xmx16m Test
Total: 16252928; free: 15965064
Total: 16252928; free: 14003496
Total: 16252928; free: 12001896
LongFinalize finalizer
Total: 16252928; free: 14290408
Total: 16252928; free: 12288808
Total: 16252928; free: 14777432
Total: 16252928; free: 12775832
Total: 16252928; free: 15286960
Total: 16252928; free: 13280880

जैसा कि आप देख सकते हैं, LongFinalize.finalize () कॉल करने के बावजूद, कचरा संग्रहकर्ता काम करना जारी रखता है। अब हम BigObject ऑब्जेक्ट में अपना फाइनल () विधि जोड़ते हैं, जो कुछ महत्वहीन है:

  static class BigObject { char[] tmp = new char[10000]; protected void finalize() throws Throwable { tmp[0] = 1; } } 

इस बार तस्वीर अलग है:
$ java -Xms16m -Xmx16m Test
Total: 16252928; free: 15965064
Total: 16252928; free: 14003496
Total: 16252928; free: 12001896
LongFinalize finalizer
Total: 16252928; free: 9996648
Total: 16252928; free: 7987144
Total: 16252928; free: 6459728
Total: 16252928; free: 4458128
Total: 16252928; free: 6357016
Total: 16252928; free: 4347352
Total: 16252928; free: 2331112
Total: 16252928; free: 329512
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at Test$BigObject.<init>(Test.java:12)
at Test.main(Test.java:31)

ध्यान दें कि एक बार मेमोरी अभी भी बड़ी हो गई थी: उन BigObject ऑब्जेक्ट्स को नष्ट कर दिया गया था जिसके लिए अंतिम रूप () LongFinalize.finalizer () से पहले निष्पादित करने में कामयाब रहे।

मैंने ऊपर लिखा है कि केवल उन वस्तुओं को अंतिम रूप नहीं दिया जाता है () ऐसी परिस्थितियों में सही ढंग से हटा दी जाती हैं। वास्तव में, यह पर्याप्त है कि अंतिम () विधि खाली है। यदि अंतिम () निकाय में कोड होता है, तो कचरा संग्राहक केवल अंतिम पंक्ति में एक वस्तु जोड़ता है। उदाहरण के लिए, हम खाली फाइनल के साथ एक बच्चा वर्ग बना सकते हैं ():

  static class SubBigObject extends BigObject { protected void finalize() throws Throwable { } } 

और चाइल्ड क्लास की वस्तुओं को मुख्य में बनाएँ () (नए सबऑब्जेक्ट (नए सब-ऑबजेक्ट के साथ) की जगह)। हम देखेंगे कि कचरा संग्रहण फिर से सफल है।

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

इसे System.runFinalization () जैसी किसी चीज के बारे में भी कहा जाना चाहिए। यह कॉल एक दूसरा थ्रेड बनाता है, "SecondaryFinalizer", जो एक ही कतार से वस्तुओं पर अंतिम रूप () भी कहता है। उसी समय, थ्रेड। जिसे System.runFinalization () कहा जाता है, वह फ़ाइनलाइज़र कतार तक प्रतीक्षा करता है, जो वर्तमान में उपलब्ध है, समाप्त होता है। सिद्धांत रूप में, यह आपको OutOfMemory से बचा सकता है यदि मुख्य फ़ाइनलीज़र फ़्रीज़ हो जाता है। हम SubBigObject के बिना कार्यक्रम के संस्करण पर लौटते हैं और यदि पर्याप्त मेमोरी शेष नहीं है, तो इस कॉल को जोड़ें। ताकि आप भ्रमित न हों, मैं पूरा पाठ दूंगा:

 public final class Test { static class LongFinalize { protected void finalize() throws Throwable { System.out.println("LongFinalize finalizer"); Thread.sleep(10000000); } } static class BigObject { char[] tmp = new char[10000]; protected void finalize() throws Throwable { tmp[0] = 1; } } public static void main(String... args) { int i=0; new LongFinalize(); while(true) { new BigObject(); try { Thread.sleep(10); } catch( InterruptedException e ) {} if(i++%100==0) System.out.println("Total: "+Runtime.getRuntime().totalMemory()+ "; free: "+Runtime.getRuntime().freeMemory()); if(Runtime.getRuntime().freeMemory()<1e6) System.runFinalization(); } } } 

आइए काम का परिणाम देखें:
$ java -Xms16m -Xmx16m Test
Total: 16252928; free: 15965064
Total: 16252928; free: 14003496
Total: 16252928; free: 12001896
LongFinalize finalizer
Total: 16252928; free: 9996648
Total: 16252928; free: 7987144
Total: 16252928; free: 6459832
Total: 16252928; free: 4458232
Total: 16252928; free: 6357120
Total: 16252928; free: 4347456
Total: 16252928; free: 2331216
Total: 16252928; free: 239072
Total: 16252928; free: 11729800
Total: 16252928; free: 9717584
Total: 16252928; free: 7719416
Total: 16252928; free: 5710768
Total: 16252928; free: 3721880
Total: 16252928; free: 1710824
Total: 16252928; free: 11261488

इस कार्यक्रम को जीना जारी है, इस तथ्य के बावजूद कि मुख्य फाइनलिज़र () लटका हुआ है। बेशक, यह आपको नहीं बचाएगा यदि लंबे समय तक अंतिम रूप () के साथ कतार में बहुत सारी वस्तुएं हैं, और आमतौर पर प्रोग्राम में System.runFinalization () के लिए एक स्पष्ट कॉल यह इंगित करने की अधिक संभावना है कि कुछ गलत है।