Python Language
कचरा इकठा करना

टिप्पणियों

/* Break reference cycles by clearing the containers involved.  This is
 * tricky business as the lists can be changing and we don't know which
 * objects may be freed.  It is possible I screwed something up here.
 */
static void
delete_garbage(PyGC_Head *collectable, PyGC_Head *old)

class A(object):
    def __init__(self, b=None):
        self.b = b
 
    def __del__(self):
        print("We're deleting an instance of A containing:", self.b)
     
class B(object):
    def __init__(self, a=None):
        self.a = a
 
    def __del__(self):
        print("We're deleting an instance of B containing:", self.a)

/* list of uncollectable objects */
static PyObject *garbage = NULL;

संदर्भ की गिनती

पाइथन मेमोरी मैनेजमेंट का अधिकांश हिस्सा संदर्भ गणना के साथ संभाला जाता है।

जब भी किसी वस्तु को संदर्भित किया जाता है (उदाहरण के लिए एक चर को सौंपा जाता है), तो उसकी संदर्भ संख्या अपने आप बढ़ जाती है। जब इसे घटाया जाता है (जैसे चर दायरे से बाहर हो जाता है), तो इसकी संदर्भ संख्या अपने आप कम हो जाती है।

जब संदर्भ गणना शून्य तक पहुंच जाती है, तो वस्तु तुरंत नष्ट हो जाती है और स्मृति तुरंत मुक्त हो जाती है। इस प्रकार अधिकांश मामलों के लिए, कचरा कलेक्टर की आवश्यकता भी नहीं है।

>>> import gc; gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> def foo():
        Track()
        # destructed immediately since no longer has any references
        print("---")
        t = Track()
        # variable is referenced, so it's not destructed yet
        print("---")
        # variable is destructed when function exits
>>> foo()
Initialized
Destructed
---
Initialized
---
Destructed

संदर्भों की अवधारणा को आगे प्रदर्शित करने के लिए:

>>> def bar():
        return Track()
>>> t = bar()
Initialized
>>> another_t = t  # assign another reference
>>> print("...")
...
>>> t = None          # not destructed yet - another_t still refers to it
>>> another_t = None  # final reference gone, object is destructed
Destructed

संदर्भ चक्र के लिए कचरा कलेक्टर

यदि आपके पास एक संदर्भ चक्र है, तो केवल कचरा कलेक्टर की आवश्यकता है। संदर्भ चक्र का उदाहरण उदाहरण वह है जिसमें A, B को संदर्भित करता है और B A को संदर्भित करता है, जबकि अन्य कुछ भी A या B को संदर्भित नहीं करता है। न तो A या B कार्यक्रम में कहीं से भी पहुँच योग्य हैं, इसलिए वे सुरक्षित रूप से नष्ट हो सकते हैं, अभी तक उनके संदर्भ संख्या 1 हैं और इसलिए उन्हें केवल संदर्भ गणना एल्गोरिथ्म द्वारा मुक्त नहीं किया जा सकता है।

>>> import gc; gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> A = Track()
Initialized
>>> B = Track()
Initialized
>>> A.other = B
>>> B.other = A
>>> del A; del B  # objects are not destructed due to reference cycle
>>> gc.collect()  # trigger collection
Destructed
Destructed
4

एक संदर्भ चक्र मनमाना लंबा हो सकता है। यदि A, B को इंगित करता है, तो C को ... को इंगित करता है, जो A को इंगित करता है, तो न तो A को Z के माध्यम से एकत्र किया जाएगा, जब तक कि कचरा संग्रहण चरण:

>>> objs = [Track() for _ in range(10)]
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
Initialized
>>> for i in range(len(objs)-1):
...     objs[i].other = objs[i + 1]
...
>>> objs[-1].other = objs[0]  # complete the cycle
>>> del objs                  # no one can refer to objs now - still not destructed
>>> gc.collect()
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
Destructed
20

डेल कमांड के प्रभाव

del v का उपयोग कर दायरे से एक चर नाम को हटाना, या del v[item] या del[i:j] का उपयोग करके किसी संग्रह से एक वस्तु को हटाना, या del v.name । या किसी अन्य तरीके से संदर्भ को हटाने का उपयोग करके किसी विशेषता को हटाना। एक वस्तु, किसी भी नाशक कॉल ट्रिगर नहीं करता या किसी स्मृति में और स्वयं का मुक्त कर दिया जा रहा है। वस्तुओं को केवल तब नष्ट किया जाता है जब उनकी संदर्भ संख्या शून्य तक पहुंच जाती है।

>>> import gc
>>> gc.disable()  # disable garbage collector
>>> class Track:
        def __init__(self):
            print("Initialized")
        def __del__(self):
            print("Destructed")
>>> def bar():
    return Track()
>>> t = bar()
Initialized
>>> another_t = t  # assign another reference
>>> print("...")
...
>>> del t          # not destructed yet - another_t still refers to it
>>> del another_t  # final reference gone, object is destructed
Destructed

आदिम वस्तुओं का पुन: उपयोग

ध्यान देने वाली एक दिलचस्प बात जो आपके अनुप्रयोगों को अनुकूलित करने में मदद कर सकती है वह यह है कि आदिम वास्तव में हुड के नीचे भी हैं। आइए संख्याओं पर एक नज़र डालें; -5 और 256 के बीच सभी पूर्णांकों के लिए, पायथन हमेशा एक ही वस्तु का पुन: उपयोग करता है:

>>> import sys
>>> sys.getrefcount(1)
797
>>> a = 1
>>> b = 1
>>> sys.getrefcount(1)
799

ध्यान दें कि प्रतिफल बढ़ता है, जिसका अर्थ है कि a और b a ही अंतर्निहित वस्तु का संदर्भ देते हैं जब वे 1 आदिम को संदर्भित करते हैं। हालाँकि, बड़ी संख्या के लिए, पायथन वास्तव में अंतर्निहित वस्तु का पुन: उपयोग नहीं करता है:

>>> a = 999999999
>>> sys.getrefcount(999999999)
3
>>> b = 999999999
>>> sys.getrefcount(999999999)
3

क्योंकि 999999999 लिए 999999999 बदलाव नहीं होता है क्योंकि इसे a और b को असाइन करने पर हम अनुमान लगा सकते हैं कि वे दो अलग-अलग अंतर्निहित वस्तुओं का उल्लेख करते हैं, भले ही वे दोनों एक ही आदिम असाइन किए गए हों।

किसी वस्तु का प्रतिफलन देखना

>>> import sys
>>> a = object()
>>> sys.getrefcount(a)
2
>>> b = a
>>> sys.getrefcount(a)
3
>>> del b
>>> sys.getrefcount(a)
2

जबरदस्ती वस्तुओं का निपटारा करना

आप ऑब्जेक्ट को हटा सकते हैं, भले ही उनका पाइथन 2 और 3 दोनों में रिफकाउंट न हो।

दोनों संस्करण ऐसा करने के लिए ctypes मॉड्यूल का उपयोग करते हैं।

चेतावनी: ऐसा करने से आपका पायथन वातावरण अस्थिर होगा और ट्रेसबैक के बिना दुर्घटनाग्रस्त होने का खतरा होगा! इस पद्धति का उपयोग करने से सुरक्षा समस्याएँ भी सामने आ सकती हैं (काफी असंभावित) केवल उन वस्तुओं को हटा दें जिनके बारे में आप सुनिश्चित हैं कि आप फिर कभी संदर्भ नहीं देंगे। कभी।

import ctypes
deallocated = 12345
ctypes.pythonapi._Py_Dealloc(ctypes.py_object(deallocated))

import ctypes, sys
deallocated = 12345
(ctypes.c_char * sys.getsizeof(deallocated)).from_address(id(deallocated))[:4] = '\x00' * 4

दौड़ने के बाद, अब निपटाए गए ऑब्जेक्ट के किसी भी संदर्भ में पाइथन के कारण या तो बिना किसी अपरिचित व्यवहार या दुर्घटना के उत्पादन होगा - ट्रेसबैक के बिना। शायद एक कारण था कि कचरा संग्रहकर्ता ने उस वस्तु को क्यों नहीं हटाया ...

यदि आप None , तो आपको एक विशेष संदेश मिलता है - Fatal Python error: deallocating None दुर्घटनाग्रस्त होने से पहले Fatal Python error: deallocating None ।

कचरा संग्रहण का प्रबंध करना

एक मेमोरी क्लीनअप करने पर प्रभावित करने के दो तरीके हैं। वे यह प्रभावित कर रहे हैं कि स्वचालित प्रक्रिया कितनी बार की जाती है और दूसरी मैन्युअल रूप से सफाई शुरू कर रही है।

कलेक्शन थ्रेसहोल्ड को ट्यून करके कचरा कलेक्टर में हेरफेर किया जा सकता है जो उस आवृत्ति को प्रभावित करता है जिस पर कलेक्टर चलता है। पायथन एक पीढ़ी आधारित स्मृति प्रबंधन प्रणाली का उपयोग करता है। नई वस्तुओं को नई पीढ़ी में बचाया जाता है - Gener0 और प्रत्येक जीवित संग्रह के साथ, वस्तुओं को पुरानी पीढ़ियों तक बढ़ावा दिया जाता है। अंतिम पीढ़ी - पीढ़ी 2 तक पहुंचने के बाद, अब उनका प्रचार नहीं किया जाता है।

निम्नलिखित स्निपेट का उपयोग करके थ्रेसहोल्ड को बदला जा सकता है:

import gc
gc.set_threshold(1000, 100, 10) # Values are just for demonstration purpose

पहला तर्क जनरेशन इकट्ठा करने की सीमा का प्रतिनिधित्व करता है। हर बार जब आवंटन की संख्या 1000 से deallocations की संख्या से अधिक कचरा कलेक्टर बुलाया जाएगा।

प्रक्रिया को अनुकूलित करने के लिए पुरानी पीढ़ियों को प्रत्येक रन पर साफ नहीं किया जाता है। दूसरी और तीसरी दलीलें वैकल्पिक हैं और नियंत्रित करती हैं कि पुरानी पीढ़ियों को कितनी बार साफ किया जाता है। यदि generation0 generation1 सफाई के बिना 100 बार संसाधित किया गया था, तो generation1 कार्रवाई की जाएगी। इसी प्रकार, जनरेशन 2 में वस्तुओं को केवल तभी संसाधित किया जाएगा जब जनरेशन 1 में बिना जनरेशन टच 2 के 10 बार सफाई की गई हो।

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

निम्न स्निपेट में संग्रह को मैन्युअल रूप से ट्रिगर किया जा सकता है:

import gc
gc.collect()

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

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

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

कचरा संग्रह के साफ होने का इंतजार न करें

तथ्य यह है कि कचरा संग्रह साफ हो जाएगा इसका मतलब यह नहीं है कि आपको कचरा संग्रह चक्र की सफाई के लिए इंतजार करना चाहिए।

विशेष रूप से आपको फ़ाइल संग्रह, डेटाबेस कनेक्शन और खुले नेटवर्क कनेक्शन को बंद करने के लिए कचरा संग्रह की प्रतीक्षा नहीं करनी चाहिए।

उदाहरण के लिए:

निम्नलिखित कोड में, आप मान लेते हैं कि फ़ाइल अगले कचरा संग्रह चक्र पर बंद हो जाएगी, अगर फ़ाइल का अंतिम संदर्भ f था।

>>> f = open("test.txt")
>>> del f

सफाई करने का एक अधिक स्पष्ट तरीका f.close() को कॉल f.close() । आप इसे और भी सुरुचिपूर्ण तरीके से कर सकते हैं, जो कि कथन के with उपयोग किया जाता है, जिसे संदर्भ प्रबंधक के रूप में भी जाना जाता है:

>>> with open("test.txt") as f:
...     pass
...     # do something with f
>>> #now the f object still exists, but it is closed

स्टेटमेंट के with आप खुली फाइल के तहत अपने कोड को इंडेंट कर सकते हैं। इससे यह स्पष्ट और आसान हो जाता है कि किसी फ़ाइल को कितनी देर तक खुला रखा जाए। यह भी हमेशा एक फ़ाइल बंद कर देता है, भले ही एक अपवाद में उठाया है while ब्लॉक।