2011-04-17 16 views
5

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

उपकरण पैकेज के getObjectSize() का उपयोग करके इसे गणना करना चाहता था लेकिन ऐसा लगता है कि वांछित काम नहीं कर रहा है।

जब मुझे मिलता है तो ऑब्जेक्ट साइज (एक स्ट्रिंग) जो भी स्ट्रिंग का आकार होता है, यह वही आकार देता है: 32. मुझे लगता है कि यह स्ट्रिंग के संदर्भ आकार का उपयोग कर रहा है या ऐसा कुछ नहीं है। तो इस समस्या को कुशलतापूर्वक हल करने के बारे में नहीं जानते।

क्या आपके पास कोई विचार है?

बहुत बहुत धन्यवाद!

उत्तर

4

आप के साथ Ehcache का उपयोग करने पर विचार करना चाहेंगे।

+0

Thx, जो मुझे लगता है कि नौकरी और शायद मेरे लागू कैश की तुलना में बेहतर होना चाहिए। आप किस प्रकार का कैश सुझाएंगे? प्रविष्टियों या कैश के आकार के आधार पर? यह जानकर कि एप्लिकेशन को सर्वर पर चलाना है और मशीन पर उपलब्ध सभी मेमोरी ले सकते हैं। – Abbadon

1

यदि आपकी चाबियाँ और मान दोनों तार हैं, तो गणना आसान है: स्ट्रिंग में प्रति चरित्र ऑब्जेक्ट ओवरहेड + 2 बाइट्स। 32-बिट सूर्य जेवीएम पर, ओवरहेड के लिए 32 बाइट सही लगता है।

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

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

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

+0

+1 ... अतिरिक्त नोट: * "चरित्र" * वास्तव में जावा चार पर फिट बैठता है। अगर किसी कारण से ओपी यूनिकोड 3.1 और ऊपर के बाद से उपलब्ध बहुत से पात्रों के साथ काम कर रहा है, तो दो जावा * char * s की आवश्यकता होती है (क्योंकि एक जावा * char * केवल यूनिकोड 3.0 कोडपॉइंट्स रख सकता है) और इसलिए, 4 बाइट्स प्रति "चरित्र" :) – SyntaxT3rr0r

+0

उत्तर के लिए Thx, यह बहुत दिलचस्प है, इसलिए शायद मैं प्रविष्टियों की संख्या का चयन करूंगा। वास्तव में स्ट्रिंग में आमतौर पर दो मान होते हैं, अधिकतम 140 वर्णों के वास्तव में छोटे तार होते हैं, और बहुत बड़े तार जो मूल्यों के एक सेट का प्रतिनिधित्व करते हैं, आमतौर पर छोटे तारों को अधिक बार होना चाहिए। प्रविष्टि के पुनर्निर्माण की लागत एक आम सहमति एल्गोरिदम और बैंडविड्थ चल रही है, इसलिए मैं कहूंगा कि यह आकार के समान नहीं है लेकिन बड़ी प्रविष्टियां अभी भी पुनर्निर्माण के लिए और अधिक कठिन हैं। बड़े तारों को भी कम किया जा सकता है। – Abbadon

+0

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

संबंधित मुद्दे