खैर, यहाँ एक में कई सवाल हैं!
1 - अल्पकालिक वस्तुओं का प्रबंधन कैसे किया जाता है?
जैसा कि पहले कहा गया था, जेवीएम पूरी तरह से अल्पकालिक वस्तु की एक बड़ी मात्रा से निपट सकता है, क्योंकि यह कमजोर पीढ़ी की परिकल्पना का अनुसरण करता है ।
ध्यान दें कि हम उन वस्तुओं की बात कर रहे हैं जो मुख्य मेमोरी (ढेर) तक पहुंच गए हैं। ऐसी स्थिति हर बार नहीं होती है। आपके द्वारा बनाई गई बहुत सी वस्तुएँ सीपीयू रजिस्टर को भी नहीं छोड़ती हैं। उदाहरण के लिए, इस लूप के लिए विचार करें
for(int i=0, i<max, i++) {
// stuff that implies i
}
चलो लूप के अनियंत्रित होने के बारे में नहीं सोचते हैं (एक अनुकूलन जो आपके कोड पर जेवीएम भारी प्रदर्शन करता है)। यदि maxइसके बराबर है Integer.MAX_VALUE, तो आपको निष्पादित करने में कुछ समय लग सकता है। हालांकि, iचर लूप-ब्लॉक से कभी नहीं बच पाएगा। इसलिए जेवीएम उस चर को सीपीयू रजिस्टर में डाल देगा, इसे नियमित रूप से बढ़ाएगा लेकिन इसे मुख्य मेमोरी में वापस नहीं भेजेगा।
इसलिए, लाखों वस्तुओं का निर्माण एक बड़ी बात नहीं है यदि उनका उपयोग केवल स्थानीय रूप से किया जाता है। ईडन में संग्रहीत होने से पहले वे मृत हो जाएंगे, इसलिए जीसी भी उन्हें नोटिस नहीं करेंगे।
2 - क्या जीसी के ओवरहेड को कम करना उपयोगी है?
हमेशा की तरह, यह निर्भर करता है।
सबसे पहले, आपको GC लॉगिंग के बारे में स्पष्ट दृष्टिकोण रखने में सक्षम होना चाहिए। आप इसे सक्षम कर सकते हैं -Xloggc:gc.log -XX:+PrintGCDetails।
यदि आपका आवेदन जीसी चक्र में बहुत समय बिता रहा है, तो, हाँ, जीसी को ट्यून करें, अन्यथा, यह वास्तव में इसके लायक नहीं हो सकता है।
उदाहरण के लिए, यदि आपके पास हर 100ms में एक युवा GC है जो 10ms लेता है, तो आप अपना 10% समय GC में बिताते हैं, और आपके पास प्रति सेकंड 10 संग्रह हैं (जो कि Huuuuuge है)। ऐसे मामले में, मैं जीसी ट्यूनिंग में कोई समय नहीं बिताऊंगा, क्योंकि 10 जीसी / एस अभी भी वहां मौजूद हैं।
3 - कुछ अनुभव
मुझे एक आवेदन पर एक समान समस्या थी जो एक दिए गए वर्ग की एक बड़ी राशि बना रही थी। जीसी लॉग में, मैंने देखा कि एप्लिकेशन की निर्माण दर लगभग 3 जीबी / एस थी, जो कि बहुत अधिक है (चलो ... हर सेकंड 3 गीगाबाइट डेटा!)।
समस्या: बहुत अधिक लगातार जीसी के कारण बहुत अधिक वस्तुओं का निर्माण हो रहा है।
मेरे मामले में, मैंने एक मेमोरी प्रोफाइलर को संलग्न किया और देखा कि एक वर्ग ने मेरी सभी वस्तुओं का एक बड़ा प्रतिशत प्रतिनिधित्व किया। मैंने यह जानने के लिए तात्कालिकता पर नज़र रखी कि यह वर्ग मूल रूप से एक वस्तु में लिपटे बूलियनों की एक जोड़ी थी। उस मामले में, दो समाधान उपलब्ध थे:
एल्गोरिथ्म को फिर से तैयार करें ताकि मैं एक जोड़ी बूलियन वापस न कर दूं लेकिन इसके बजाय मेरे पास दो तरीके हैं जो प्रत्येक बूलियन को अलग से लौटाते हैं
वस्तुओं को कैश करें, यह जानते हुए कि केवल 4 अलग-अलग उदाहरण थे
मैंने दूसरे को चुना, क्योंकि इसका आवेदन पर कम से कम प्रभाव पड़ा और परिचय करना आसान था। मुझे एक थ्रेड-नॉट-सेफ कैश के साथ एक फैक्ट्री लगाने में मिनटों का समय लगा (मुझे थ्रेड सेफ्टी की जरूरत नहीं थी क्योंकि आखिरकार मेरे पास केवल 4 अलग-अलग इंस्टेंसेस होंगे)।
आवंटन दर 1 जीबी / एस तक नीचे चली गई, और इसलिए युवा जीसी की आवृत्ति (3 से विभाजित) हुई।
उम्मीद है की वो मदद करदे !