आप सभी को पायथन में कचरा संग्रहकर्ता के बारे में जानना होगा

आमतौर पर, जब आप पायथन कोड लिखते हैं, तो आपको कचरा संग्रहकर्ता और स्मृति के साथ काम करने की चिंता करने की आवश्यकता नहीं है। जैसे ही वस्तुओं की आवश्यकता नहीं होती है, पायथन स्वचालित रूप से उनके नीचे से स्मृति को मुक्त कर देता है। इसके बावजूद, यह समझना कि जीसी कैसे काम करता है, आपको बेहतर कोड लिखने में मदद करेगा।

मेमोरी मैनेजर

अन्य लोकप्रिय भाषाओं के विपरीत, पायथन किसी ऑब्जेक्ट को हटाते ही सभी मेमोरी को ऑपरेटिंग सिस्टम पर वापस नहीं करता है। इसके बजाय, यह छोटी वस्तुओं के लिए डिज़ाइन किया गया एक अतिरिक्त मेमोरी मैनेजर का उपयोग करता है (जिसका आकार 512 बाइट्स से कम है)। ऐसी वस्तुओं के साथ काम करने के लिए, वह स्मृति के बड़े ब्लॉकों को आवंटित करता है, जिसमें भविष्य में कई छोटी वस्तुओं को संग्रहीत किया जाएगा।

जैसे ही छोटी वस्तुओं में से एक को हटा दिया जाता है - इसके नीचे से मेमोरी ऑपरेटिंग सिस्टम पर नहीं जाती है, पायथन उसी आकार के साथ नई वस्तुओं के लिए छोड़ देता है। यदि आवंटित मेमोरी ब्लॉकों में से एक में कोई ऑब्जेक्ट नहीं बचा है, तो पायथन इसे ऑपरेटिंग सिस्टम को जारी कर सकता है। आमतौर पर, ब्लॉक जारी किए जाते हैं जब स्क्रिप्ट कई अस्थायी ऑब्जेक्ट बनाती है।

इस प्रकार, यदि लंबे समय तक रहने वाली पायथन प्रक्रिया समय के साथ अधिक मेमोरी का उपभोग करना शुरू कर देती है, तो इसका मतलब यह नहीं है कि आपके कोड में मेमोरी की समस्या है। यदि आप पायथन में मेमोरी मैनेजर के बारे में अधिक जानना चाहते हैं, तो आप इसके बारे में मेरे अन्य लेख में पढ़ सकते हैं।

कचरा संग्रह एल्गोरिदम

मानक अजगर इंटरप्रेटर (CPython) एक ही बार में दो एल्गोरिदम का उपयोग करता है, संदर्भ गिनती और जेनेरिक कचरा कलेक्टर (इसके बाद GC), जिसे पायथन से मानक gc मॉड्यूल के रूप में जाना जाता है।

लिंक गणना एल्गोरिथ्म बहुत सरल और कुशल है, लेकिन इसमें एक बड़ी खामी है। वह नहीं जानता कि परिपत्र संदर्भों को कैसे परिभाषित किया जाए। यह इस कारण से है कि अजगर में एक अतिरिक्त कलेक्टर होता है जिसे जेनेशनल जीसी कहा जाता है जो संभावित परिपत्र संदर्भों के साथ वस्तुओं की निगरानी करता है।

पायथन में, संदर्भ गणना एल्गोरिथ्म मौलिक है और इसे अक्षम नहीं किया जा सकता है, जबकि जीसी वैकल्पिक है और इसे अक्षम किया जा सकता है।

लिंक की गिनती एल्गोरिथम

लिंक गिनती एल्गोरिथ्म सबसे आसान कचरा संग्रह तकनीकों में से एक है। जैसे ही वे संदर्भित किए जाते हैं, ऑब्जेक्ट हटा दिए जाते हैं।

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

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

लिंक की संख्या बढ़ने पर उदाहरण:

• असाइनमेंट ऑपरेटर
• तर्क पारित करना
• शीट में एक नई वस्तु डालें (ऑब्जेक्ट के लिंक की संख्या बढ़ जाती है)
• फार्म फू = बार का निर्माण (फू बार के समान वस्तु को संदर्भित करना शुरू करता है)

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

उदाहरण के लिए, यदि कोई सूची हटा दी जाती है, तो उसके सभी तत्वों में संदर्भ संख्या एक से कम हो जाती है। यदि सूची के भीतर सभी वस्तुओं का उपयोग कहीं और नहीं किया जाता है, तो उन्हें भी हटा दिया जाएगा।

चर जिन्हें बाहरी कार्यों, वर्गों और ब्लॉकों के रूप में घोषित किया जाता है उन्हें वैश्विक कहा जाता है। आमतौर पर, ऐसे चरों का जीवन चक्र पायथन प्रक्रिया के जीवन के बराबर होता है। इस प्रकार, वैश्विक चर द्वारा संदर्भित वस्तुओं की संख्या कभी भी शून्य तक नहीं जाती है।

किसी ब्लॉक (फ़ंक्शन, क्लास) के अंदर घोषित होने वाले वेरिएबल्स में लोकल विजिबिलिटी होती है (यानी वे ब्लॉक के अंदर ही दिखाई देते हैं)। जैसे ही अजगर दुभाषिया ब्लॉक से बाहर निकलता है, यह उसके अंदर स्थानीय चरों द्वारा बनाए गए सभी लिंक को नष्ट कर देता है।

आप हमेशा sys.getrefcount फ़ंक्शन का उपयोग करके लिंक की संख्या की जांच कर सकते हैं।

लिंक काउंटर का उदाहरण:

 foo = [] # 2 ,    foo    getrefcount print(sys.getrefcount(foo)) def bar(a): # 4  #  foo,   (a), getrefcount       print(sys.getrefcount(a)) bar(foo) # 2 ,      print(sys.getrefcount(foo)) 

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

इस एल्गोरिथ्म का मुख्य लाभ यह है कि वस्तुओं को तुरंत हटा दिया जाता है जैसे ही उन्हें आवश्यकता नहीं होती है।

वैकल्पिक कचरा कलेक्टर

जब हमें पहले से ही संदर्भ गिनती है, तो हमें एक अतिरिक्त एल्गोरिथ्म की आवश्यकता क्यों है?

दुर्भाग्य से, क्लासिक लिंक काउंटिंग एल्गोरिथ्म में एक बड़ी खामी है - यह नहीं जानता कि परिपत्र लिंक कैसे खोजना है। लूपबैक तब होता है जब एक या अधिक ऑब्जेक्ट एक दूसरे को संदर्भित करते हैं।

दो उदाहरण:



जैसा कि आप देख सकते हैं, object1 ऑब्जेक्ट खुद को संदर्भित करता है, जबकि ऑब्जेक्ट lst ऑब्जेक्ट 2 एक दूसरे को संदर्भित करते हैं। ऐसी वस्तुओं के लिए, संदर्भ संख्या हमेशा 1 होगी।

पायथन डेमो:

 import gc #  ctypes        class PyObject(ctypes.Structure): _fields_ = [("refcnt", ctypes.c_long)] gc.disable() #   GC lst = [] lst.append(lst) #    lst lst_address = id(lst) #   lst del lst object_1 = {} object_2 = {} object_1['obj2'] = object_2 object_2['obj1'] = object_1 obj_address = id(object_1) #   del object_1, object_2 #          # gc.collect() #    print(PyObject.from_address(obj_address).refcnt) print(PyObject.from_address(lst_address).refcnt) 

ऊपर दिए गए उदाहरण में, डेल अनुदेश हमारी वस्तुओं (न कि स्वयं वस्तुओं) के संदर्भों को हटा देता है। एक बार जब Python एक del statement निष्पादित करता है, तो ये ऑब्जेक्ट Python कोड से अप्राप्य हो जाते हैं। हालांकि, जीसी मॉड्यूल बंद होने के साथ, वे अभी भी मेमोरी में बने रहेंगे, जैसे उनके पास परिपत्र संदर्भ थे और उनका काउंटर अभी भी एक है। आप नेत्रहीन पुस्तकालय का उपयोग करके ऐसे संबंधों को नेत्रहीन रूप से देख सकते हैं।

इस समस्या को ठीक करने के लिए, एक अतिरिक्त एल्गोरिथ्म जिसे gc मॉड्यूल के रूप में जाना जाता है, पाइथन 1.5 में जोड़ा गया था। जिसका एकमात्र कार्य चक्रीय वस्तुओं को हटाना है जिससे अब कोड तक पहुंच नहीं है।

लूपबैक केवल "कंटेनर" ऑब्जेक्ट में हो सकते हैं। यानी ऑब्जेक्ट्स में जो अन्य ऑब्जेक्ट्स को स्टोर कर सकते हैं, जैसे सूचियाँ, शब्दकोश, कक्षाएं, और टुपल्स। जीसी सरल और अपरिवर्तनीय प्रकारों पर नज़र नहीं रखता है, टुपल्स को छोड़कर। कुछ शर्तों को पूरा करने पर कुछ ट्यूल और शब्दकोशों को ट्रैकिंग सूची से भी बाहर रखा गया है। अन्य सभी वस्तुओं के साथ, संदर्भ गणना एल्गोरिथ्म का सामना करने की गारंटी है।

जब जीसी ट्रिगर किया जाता है

संदर्भ गणना एल्गोरिथ्म के विपरीत, चक्रीय जीसी वास्तविक समय में काम नहीं करता है और समय-समय पर चलता है। कलेक्टर का प्रत्येक रन कोड में माइक्रो-पॉज बनाता है, इसलिए CPython (मानक दुभाषिया) कचरा संग्रहकर्ता की आवृत्ति निर्धारित करने के लिए विभिन्न अनुमानों का उपयोग करता है।

चक्रीय कचरा संग्राहक सभी वस्तुओं को 3 पीढ़ियों (पीढ़ियों) में विभाजित करता है। नई वस्तुएँ पहली पीढ़ी में आती हैं। यदि नई सुविधा कचरा संग्रहण प्रक्रिया से बच जाती है, तो यह अगली पीढ़ी के लिए चलती है। जितनी अधिक पीढ़ी होती है, उतनी ही बार यह कचरा के लिए स्कैन किया जाता है। चूंकि नई वस्तुओं में अक्सर बहुत कम उम्र होती है (अस्थायी होती है), इसलिए यह उन लोगों की तुलना में अधिक बार साक्षात्कार करने के लिए समझ में आता है जो पहले से ही कचरा संग्रह के कई चरणों से गुजर चुके हैं।

प्रत्येक पीढ़ी के पास एक विशेष काउंटर और एक प्रतिक्रिया दहलीज होती है, जिस पर पहुंचने पर कचरा संग्रहण प्रक्रिया शुरू हो जाती है। प्रत्येक काउंटर किसी दिए गए पीढ़ी में आवंटन की संख्या को घटाकर जमा की संख्या को संग्रहीत करता है। जैसे ही कोई कंटेनर ऑब्जेक्ट पाइथन में बनता है, वह इन काउंटरों की जांच करता है। यदि स्थितियां काम करती हैं, तो कचरा संग्रहण प्रक्रिया शुरू होती है।

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

पीढ़ियों के लिए मानक थ्रेसहोल्ड क्रमशः 700, 10 10 सेट हैं, लेकिन आप हमेशा gc.get_threshold gc.set_threshold का उपयोग करके उन्हें बदल सकते हैं।

लूप खोज एल्गोरिथम

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

एक गहरी समझ के लिए, मैं पढ़ने की सलाह देता हूं (अनुवादक का नोट: अंग्रेजी सामग्री) नील स्कीनेनॉयर से एल्गोरिथ्म का मूल विवरण और सीपीथॉन स्रोतों से collect समारोह। क्वोरा का एक विवरण और कचरा कलेक्टर के बारे में एक पोस्ट भी उपयोगी हो सकता है।

यह ध्यान देने योग्य है कि एल्गोरिथ्म के मूल विवरण में वर्णित विनाशकों के साथ समस्या पायथन 3.4 ( पीईपी 442 में अधिक विवरण) के बाद से तय की गई है।

अनुकूलन युक्तियाँ

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

उन जगहों पर जहां आप जानबूझकर परिपत्र लिंक का उपयोग करते हैं, आप "कमजोर" लिंक का उपयोग कर सकते हैं। कमजोर लिंक कमजोर मॉड्यूल में लागू किए जाते हैं और, नियमित लिंक के विपरीत, लिंक काउंटर को किसी भी तरह से प्रभावित नहीं करते हैं। यदि कमजोर संदर्भ वाली वस्तु को हटा दिया जाता है, तो इसके बजाय None लौटाया जाता है।

कुछ मामलों में, यह जीसी मॉड्यूल द्वारा स्वचालित निर्माण को अक्षम करने और मैन्युअल रूप से कॉल करने के लिए उपयोगी है। ऐसा करने के लिए, बस gc.disable() को कॉल करें और फिर मैन्युअल रूप से gc.collect() कॉल करें।

परिपत्र लिंक कैसे खोजे और डीबग करें

डिबगिंग लूप दर्दनाक हो सकते हैं, खासकर यदि आपका कोड कई तृतीय-पक्ष मॉड्यूल का उपयोग करता है।

जीसी मॉड्यूल सहायक कार्य प्रदान करता है जो डीबगिंग के साथ मदद कर सकता है। यदि GC पैरामीटर DEBUG_SAVEALL ध्वज पर सेट किए जाते हैं, तो सभी दुर्गम ऑब्जेक्ट्स को gc.garbage सूची में जोड़ दिया जाएगा।

 import gc gc.set_debug(gc.DEBUG_SAVEALL) print(gc.get_count()) lst = [] lst.append(lst) list_id = id(lst) del lst gc.collect() for item in gc.garbage: print(item) assert list_id == id(item) 

एक बार जब आप समस्या स्थान की पहचान कर लेते हैं - तो इसे ऑब्जर्ग का उपयोग करके देखा जा सकता है।

निष्कर्ष

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

आपको कचरा संग्राहक के लिए समय से पहले अनुकूलन में संलग्न नहीं होना चाहिए, व्यवहार में, कचरा संग्रह की समस्याएं काफी दुर्लभ हैं।

पुनश्च: मैं इस लेख का लेखक हूं, आप कोई भी प्रश्न पूछ सकते हैं।