जब भी आप अपना कोड चलाते हैं, तो आप मेमोरी का उपयोग करते हैं। जब आप रूबी जैसी भाषा में लिखते हैं, तो ऐसा लगता है कि आपके लिए उपलब्ध स्मृति अनंत है। आप अपने कोड को चलाने वाले सिस्टम की निश्चित मात्रा में मेमोरी के बारे में सोचे बिना बस चलते रह सकते हैं। इस रूबी मैजिक एपिसोड में हम बताएंगे कि यह कैसे काम करता है!
थोड़ा सा इतिहास
उस समय, रूबी जैसी स्क्रिप्टिंग भाषाएं अभी तक मौजूद नहीं थीं। लोगों ने केवल C जैसी भाषाओं में कोड लिखा, जो निम्न स्तर की प्रोग्रामिंग भाषा है। इन भाषाओं को निम्न स्तर बनाने वाली चीजों में से एक यह है कि आपको खुद के बाद सफाई करनी होगी। उदाहरण के लिए, जब भी आप String . को स्टोर करने के लिए मेमोरी आवंटित करते हैं , आपको यह भी तय करना होगा कि इसे कब साफ करना है।
मैन्युअल सफाई
यह निम्न नकली रूबी कोड जैसा कुछ दिखता है। यह एक चर घोषित करता है और free . विधि का उपयोग करता है -यह विधि वास्तव में रूबी में मौजूद नहीं है- हमारे द्वारा उपयोग की जाने वाली मेमोरी को वेरिएबल के साथ समाप्त करने के बाद साफ करने के लिए।
1_000_000.times do |i|
variable = "Variable #{i}"
puts variable
free(variable)
endप्रोग्रामिंग का एक थकाऊ तरीका
आप शायद पहले ही महसूस कर चुके होंगे कि यहां एक जोखिम है:क्या होगा यदि आप free को भूल जाते हैं चर? उस स्थिति में जब तक प्रक्रिया समाप्त नहीं हो जाती तब तक उस चर की सामग्री स्मृति में ही रहेगी। यदि आप इसे अक्सर पर्याप्त करते हैं, तो आप स्मृति से बाहर हो जाएंगे और आपकी प्रक्रिया क्रैश हो जाएगी।
अगला उदाहरण एक और आम समस्या दर्शाता है:
1_000_000.times do |i|
variable = "Variable #{i}"
free(variable)
puts variable
end
हम चर घोषित करते हैं और free यह। लेकिन फिर हम इसे फिर से इस्तेमाल करने की कोशिश करते हैं, जो असंभव है क्योंकि यह अब मौजूद नहीं है। यदि यह C होता, तो आपका प्रोग्राम अब segfault . के साथ क्रैश हो जाता . ओह!
मनुष्य गलती मशीन हैं
हर समय इस प्रकार की गलतियाँ न करने के कारण मनुष्य कुख्यात है। इसलिए स्मृति को स्वचालित रूप से साफ करने के तरीके की आवश्यकता है। ऐसा करने का सबसे लोकप्रिय तरीका-रूबी में भी इस्तेमाल किया जाता है- कचरा संग्रह (जीसी) है।
कचरा संग्रह (GC) कैसे काम करता है
जीसी का उपयोग करने वाली भाषा में, आप वस्तुओं को मैन्युअल रूप से साफ किए बिना बना सकते हैं। जब भी आप कोई ऑब्जेक्ट बनाते हैं, तो वह गारबेज कलेक्टर के पास पंजीकृत हो जाता है। जीसी इस ऑब्जेक्ट में आपके द्वारा किए गए सभी संदर्भों का ट्रैक रखने का प्रयास करता है। जब यह निर्धारित करता है कि आप अब ऑब्जेक्ट का उपयोग नहीं कर रहे हैं, तो इसे क्लीनअप के लिए चिह्नित किया जाता है। समय-समय पर कचरा संग्रहकर्ता आपके कार्यक्रम को रोक देता है और सभी चिह्नित वस्तुओं को साफ कर देता है।
कुछ उदाहरण देख रहे हैं
हमने पहले जिस साधारण लूप का इस्तेमाल किया था, उसमें जीसी का काम काफी आसान है। लूप के प्रत्येक पुनरावृत्ति के साथ, वेरिएबल का अब कहीं भी उपयोग नहीं किया जाता है। चर को तुरंत सफाई के लिए चिह्नित किया जा सकता है।
1_000_000.times do |i|
variable = "Variable #{i}"
puts variable
end
अगले उदाहरण में हम वेरिएबल को puts_later . में पास करते हैं विधि जो 30 सेकंड तक प्रतीक्षा करती है और फिर puts चर।
def puts_later(variable)
Thread.new do
sleep 30
puts variable
end
end
1_000_000.times do |i|
variable = "Variable #{i}"
puts_later variable
end
इस अपेक्षाकृत सरल उदाहरण में गारबेज कलेक्टर का कार्य पहले से ही काफी जटिल है। इसे समझना होगा कि हम वेरिएबल को puts_later . में रेफर करते हैं तरीका। चूंकि विधि एक धागा शुरू करती है, कचरा कलेक्टर को धागे का ट्रैक रखना होगा और इसके समाप्त होने की प्रतीक्षा करनी होगी। तभी वेरिएबल को क्लीनअप के लिए चिह्नित किया जा सकता है।
जब यह जटिल हो जाता है
जटिल उदाहरणों में आए बिना, मुझ पर विश्वास करें जब मैं कहता हूं कि कचरा संग्रहकर्ता का काम वास्तव में कठिन है। यह यह भी बताता है कि जीसी आपके उत्पादन वातावरण में ओवरहेड और समस्याएं क्यों पैदा कर सकता है। मेमोरी को ठीक से साफ़ करने के लिए आपके प्रोग्राम में क्या हो रहा है, इसकी बहुत विस्तृत समझ होनी चाहिए, जिसे सही होने में काफी CPU चक्र लगते हैं। लेकिन हे, यह अपने आप को साफ करने के लिए धड़कता है!
कचरा संग्रह के लिए और भी बहुत कुछ है
यह केवल कचरा संग्रह के लिए हमारा परिचय था। भविष्य के लेख में हम देखेंगे कि यह वास्तव में रूबी में कैसे काम करता है, और आप अपने आवेदन के प्रदर्शन को बेहतर बनाने के लिए जीसी को कैसे माप और ट्यून कर सकते हैं।
अपडेट करें: अगला एपिसोड यहां उपलब्ध है।