जावा रूपरेखा, प्रदर्शन ट्यूनिंग और मेमोरी रूपरेखा अभ्यास

Question

मैं के बारे में JProfiler और Eclipse Tptp. का उपयोग कर एक कार्यशाला की रूपरेखा, प्रदर्शन ट्यूनिंग, स्मृति प्रोफाइलिंग, जावा अनुप्रयोगों की स्मृति रिसाव का पता लगाने आदि का संचालन करने के मैं अभ्यास है कि मैं दे सकता का एक सेट की जरूरत है कर रहा हूँ प्रतिभागियों के लिए जहां वे कर सकते हैं: समस्या का पता लगाने के लिए टूल का उपयोग करें: बाधा, स्मृति रिसाव, उप-विषय कोड आदि। मुझे यकीन है कि बहुत सारे अनुभव और वास्तविक जीवन उदाहरण हैं।

• समस्या का समाधान करें और लागू करने के लिए अनुकूलित कोड
• आदर्श रूप में रूपरेखा का एक और सत्र प्रदर्शन से समाधान का प्रदर्शन, नहीं होना चाहिए इकाई परीक्षण है कि प्रदर्शन लाभ दर्शाता

समस्याएं और न ही समाधान बारे में अत्यधिक जटिल हो; मिनटों के मामले में सबसे अच्छा और घंटों के मामले में उन्हें हल करना संभव होना चाहिए। कुछ रोचक क्षेत्रों व्यायाम करने के लिए:

• हल स्मृति लीक
• अनुकूलन लूप
• अनुकूलन वस्तु निर्माण और प्रबंधन
• अनुकूलन स्ट्रिंग आपरेशन
• हल समस्याओं संगामिति और संगामिति ने और बढ़ा दिया बाधाओं

आदर्श रूप से, अभ्यास में नमूना अनियमित कोड शामिल होना चाहिए डी समाधान कोड डी।

Answer 1

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

परिदृश्य: आपके पास समय लेने वाला फ़ंक्शन है जिसे आप अलग-अलग मानों के लिए कई बार करना चाहते हैं, लेकिन वही मान फिर से पॉप हो सकते हैं (आदर्श रूप से इसे बनाए जाने के बाद बहुत लंबा नहीं)। एक अच्छा और सरल उदाहरण यूआरएल-वेब पेज जोड़े है जिसे आपको डाउनलोड और प्रोसेस करने की आवश्यकता है (अभ्यास के लिए इसे शायद अनुकरण किया जाना चाहिए)।

लूप्स:

• यदि शब्दों का एक सेट के किसी भी पन्नों में पॉप-अप होने जाँच करना चाहते हैं। एक पाश में अपने फ़ंक्शन का उपयोग करें, लेकिन एक ही मूल्य, छद्म कोड के साथ:

  for (word : words) { 
      checkWord(download(url)) 
  } 
  

  एक समाधान काफी आसान है, बस पाश से पहले पेज डाउनलोड करें। अन्य समाधान नीचे है।

मेमोरी रिसाव:

• सरल एक: आप भी कैश का एक प्रकार के साथ अपनी समस्या को हल कर सकते हैं। सबसे सरल मामले में आप केवल परिणामों को एक स्थिर (स्थिर) मानचित्र में डाल सकते हैं। लेकिन अगर आप इसे नहीं रोकते हैं, तो इसका आकार असीम रूप से बढ़ेगा -> स्मृति रिसाव।
  संभावित समाधान: एलआरयू मानचित्र का उपयोग करें। सबसे अधिक संभावना प्रदर्शन बहुत अधिक गिरावट नहीं होगी, लेकिन स्मृति रिसाव दूर जाना चाहिए।
• ट्रिकियर एक: कहें कि आप WeakHashMap का उपयोग कर पिछले कैश को लागू करते हैं, जहां कुंजी यूआरएल हैं (स्ट्रिंग्स के रूप में नहीं, बाद में देखें), मान उस वर्ग के उदाहरण होते हैं जिसमें यूआरएल, डाउनलोड पेज और कुछ और होता है। आप मान सकते हैं कि यह ठीक होना चाहिए, लेकिन वास्तव में यह नहीं है: क्योंकि मान (जिसे कमजोर संदर्भित नहीं किया गया है) के पास कुंजी (यूआरएल) का संदर्भ है, कुंजी कभी भी साफ करने के योग्य नहीं होगी -> अच्छी मेमोरी रिसाव ।
  समाधान: मूल्य से यूआरएल को हटा दें।
• पहले जैसा ही है, लेकिन यूआरएल तारों को प्रशिक्षित कर रहे हैं ("अगर हम एक ही तार फिर से होते हैं तो कुछ स्मृति को बचाने के लिए"), मान इसका संदर्भ नहीं देता है। मैंने कोशिश नहीं की, लेकिन ऐसा लगता है कि यह एक रिसाव भी पैदा करेगा, क्योंकि आंतरिक स्ट्रिंग्स जीसी-एड नहीं हो सकती हैं।
  समाधान: इंटर्न नहीं करें, जो सलाह भी लेगा कि आपको छोड़ना नहीं चाहिए: premature optimization, as it is the root of all evil मत करें।

वस्तु निर्माण & स्ट्रिंग्स:

• आप (~ html टैग निकालने के लिए) पृष्ठों को केवल का पाठ प्रदर्शित करना चाहते हैं। एक फ़ंक्शन लिखें जो इसे लाइन से लाइन करता है, और इसे एक बढ़ते परिणाम में जोड़ता है। सबसे पहले परिणाम एक स्ट्रिंग होना चाहिए, इसलिए संलग्न करने में बहुत समय लगेगा और ऑब्जेक्ट आवंटन होगा। आप प्रदर्शन की दृष्टि से इस समस्या का पता लगा सकते हैं (क्यों संलग्न होते हैं धीमे होते हैं) और ऑब्जेक्ट निर्माण बिंदु से (हमने इतने सारे स्ट्रिंग्स, स्ट्रिंगबफर, सरणी आदि क्यों बनाए)।
  समाधान: परिणाम के लिए एक स्ट्रिंगबिल्डर का उपयोग करें।

कन्करेंसी:

• आप समानांतर में डाउनलोड/छानने करके पूरे सामान तेजी लाने के लिए चाहते हैं। कुछ धागे बनाएं और उनका उपयोग करके अपना कोड चलाएं, लेकिन "सिंकुरेंसी समस्याओं से कैश की रक्षा के लिए", केवल एक बड़े सिंक्रनाइज़ किए गए ब्लॉक (कैश के आधार पर) के अंदर सबकुछ करें। प्रभाव यह होना चाहिए कि आप प्रभावी रूप से केवल एक धागे का उपयोग करें, क्योंकि अन्य सभी कैश पर लॉक प्राप्त करने की प्रतीक्षा कर रहे हैं।
  समाधान: सिंक्रनाइज़ केवल कैश संचालन के आसपास (जैसे का उपयोग `java.util.collections.synchronizedMap())

• सिंक्रनाइज़ कोड के सभी छोटे-छोटे टुकड़े। यह प्रदर्शन को मारना चाहिए, शायद सामान्य समानांतर निष्पादन को रोकें। यदि आप भाग्यशाली/स्मार्ट हैं तो आप एक मृत लॉक के साथ भी आ सकते हैं। इसका नैतिक: सिंक्रनाइज़ेशन एक विज्ञापन की बात नहीं होनी चाहिए, "यह चोट नहीं पहुंचाएगा" आधार पर, लेकिन एक अच्छी तरह से सोचा।

बोनस व्यायाम:

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

Answer 2

this method को अनदेखा न करें क्योंकि यह these reasons के लिए किसी भी भाषा और ओएस के लिए बहुत अच्छी तरह से काम करता है। एक उदाहरण here है। साथ ही, I/O और महत्वपूर्ण कॉल गहराई के साथ उदाहरणों का उपयोग करने का प्रयास करें। मंडलब्रॉट जैसे छोटे सीपीयू-बाध्य कार्यक्रमों का उपयोग न करें। यदि आप उस सी उदाहरण को लेते हैं, जो कि बहुत बड़ा नहीं है, और इसे जावा में रिकोड करें, तो आपके अधिकांश बिंदुओं को चित्रित करना चाहिए।

चलो देखते हैं:

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

• लूप अनुकूलित करें।
  आम तौर पर लूप को अनुकूलित करने की आवश्यकता नहीं होती है जब तक उनके अंदर बहुत कम नहीं किया जाता है (और वे समय का एक अच्छा प्रतिशत लेते हैं)।

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

• स्ट्रिंग ऑपरेशंस अनुकूलित करें।
  स्ट्रिंग बिल्डर का उपयोग करें, लेकिन कोड को पसीना न करें जो निष्पादन समय के ठोस प्रतिशत का उपयोग नहीं करता है।

• Concurrency।
  Concurrency के दो उद्देश्य हैं।
  1) प्रदर्शन, लेकिन यह केवल इस हद तक काम करता है कि यह हार्डवेयर के कई टुकड़ों को एक ही समय में क्रैंकिंग करने की अनुमति देता है। यदि हार्डवेयर नहीं है, तो यह मदद नहीं करता है। यह दुखदायक है।
  2) अभिव्यक्ति की स्पष्टता, इसलिए उदाहरण के लिए यूआई कोड को भारी गणना या नेटवर्क I/O के बारे में चिंता करने की ज़रूरत नहीं है।

किसी भी मामले में, यह काफी बल दिया नहीं जा सकता, किसी भी अनुकूलन नहीं करते इससे पहले कि आप को साबित कर दिया है कि कुछ समय के एक महत्वपूर्ण प्रतिशत लेता है।

Answer 3

मैंने अपने आवेदन को प्रोफाइल करने के लिए जेपीरोफाइलर का उपयोग किया है। लेकिन यह बहुत मदद नहीं कर रहा है। तब मैंने जेएचट का इस्तेमाल किया। जेएचट का उपयोग करके आप वास्तविक समय में ढेर नहीं देख सकते हैं। आपको एक ढेर डंप लेना है और फिर इसका विश्लेषण करना है । OQL(Object Query Language) का उपयोग ढेर लीक खोजने के लिए एक अच्छी तकनीक है।