4.0 ट्रोव किया? मानक जावा 8 संग्रह ढांचे में आदिम

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

फिलहाल, 6 प्रकार की हैश टेबल बनाई गई हैं: आदिम, वस्तुओं और सभी 4 मानचित्र प्रकारों के सेट: आदिम - आदिम, आदिम - वस्तु, वस्तु - आदिम और वस्तु - वस्तु, जिस पर सामान्यीकरण का एक बादल घूमता है।

मैं हमेशा सोचता था कि इस तरह के सभी पुस्तकालय एक अन्य प्रकार की पदानुक्रम क्यों बनाते हैं, और जावा संग्रह के लंबे समय से स्थापित मानक ढांचे में फिट नहीं होते हैं। मैंने इसके साथ कोई मौलिक समस्या नहीं देखी है और न ही देखी है। इसलिए, java.lang.Iterable , java.util.Collection और java.util.Map मेरे java.util.Map पर जैसे इंटरफेस के मेरे बादल से ऊपर उठते हैं। मैंने जानबूझकर जावा 8 प्रलेखन के लिंक दिए हैं। भविष्य के इंटरफेस से लगभग सभी तरीकों को लागू किया जाता है, spliterator() को छोड़कर। आप इसकी आदत डालना शुरू कर सकते हैं।

नए ट्रोव ढांचे के अतिरिक्त तत्व

MapIterator () जावा 8 और entrySet().iterator() spliterator() से स्प्लिटेटर () का एक हाइब्रिड है।

 interface TMapIterator<K, V> { boolean tryAdvance(); K key(); V value(); ... } //   for (IntKeyMapIterator<String> it = map.mapIterator(); it.tryAdvance(); ) { doSomething(it.intKey(), it.value()); } 

यह entrySet().iterator() तुलना में शायद ही अधिक बोझिल है, लेकिन बहुत अधिक कुशल है।

सभी ऑब्जेक्ट हैश में वस्तुओं के विभाजन को नियंत्रित करने के तरीके हैं जो समतुल्य हैं।

 class DHashSet<E> { ... protected boolean elementsEquals(@NotNull E a, @Nullable E b) { return a.equals(b); } protected int elementHashCode(@NotNull E element) { return element.hashCode(); } } 

संपूर्ण संग्रहों पर "प्रतिवर्ती" विधियाँ: addAllTo() , allContainingIn() , removeAllFrom() - धारा संचालन को गति देने के लिए। एक मानक ढांचे में, संग्रह पर हमेशा विधि को कहा जाता है, जो बदल जाएगा, हालांकि इसे दूसरे पर पुनरावृत्त करना होगा। यद्यपि उत्तरार्द्ध "जानता है" कि सभी तत्वों को जल्दी से कैसे जाना है।

कुछ मामलों में, रिवर्स पास को नियमित इट्रेटर का उपयोग करके बाहरी की तुलना में 2 गुना तेजी से किया जा सकता है। उदाहरण के लिए, जब डंपिंग एक सूची में सेट हो जाती है।

चूंकि मानक ढांचे से संबंधित विधियों के अनुबंधों में सूक्ष्म बारीकियां हैं, इसलिए मैन्युअल रूप से रिवर्स तरीकों को कॉल करने की अनुशंसा नहीं की जाती है ताकि कुछ गलत न हो। कार्यान्वयन में नियमित तरीकों से उन्हें पहले से ही बुलाया जाता है।

कार्यान्वयन

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

एक गुणांक k (0 से 1 से) के साथ, यह पता चला है कि तालिका के पुनर्निर्माण से पहले निरंतर विलोपन के साथ, k - k ^ 2 भरे हुए सेल बने हुए हैं, और k ^ 2 हटाए गए हैं, वैकल्पिक विलोपन और विभिन्न यादृच्छिक तत्वों के आवेषण के साथ - भरा (1 - k) ^ 2 - मुक्त (सभी मान 1 के अंशों में हैं)।

संख्याओं को प्रतिस्थापित करें। 0.5 के डिफ़ॉल्ट अनुपात के साथ, दोनों स्थितियों में तालिका में हटाए गए आइटम का अधिकतम एक चौथाई प्राप्त किया जाता है। बहुत सुन्दर। लेकिन 0.8 के मेरे पसंदीदा गुणांक के साथ - तालिका का उपयोग करने के पूरी तरह से सामान्य पैटर्न के साथ, केवल 4% मुक्त कोशिकाएं रह सकती हैं - यह एक अपराध है।

इसलिए, मैंने एक बहुत सरल सिद्धांत पेश किया - किसी भी समय हटाए गए कक्षों की संख्या कब्जे वाले लोगों की संख्या (यानी, तालिका का आकार) या मुक्त लोगों की संख्या से अधिक नहीं होनी चाहिए, अन्यथा, पुनर्निर्माण करें:

 class DoubleHashBase { int size, free, removed, modCount; ... final void postRemoveHook() { modCount++; if ( ( --size < ++removed || removed > free ) && autoRehashEnabled ) { rehash(); } } 

हैश तालिका को लागू करने में महत्वपूर्ण विधि एक तत्व ढूंढ रही है। डबल-हैश तालिका के मामले में, एक सरणी जिसकी लंबाई एक अभाज्य है, लगभग यादृच्छिक क्रम में कूद जाती है, और तत्व की वर्तमान सूचकांक में तुलना की जाती है। उसी समय, वे हैश तालिका में एक तत्व की तलाश करते हैं, या तो इसे बाद में वहां सम्मिलित करने के लिए, या एक समानांतर सरणी ( map.get() या set.contains() ) से एक मान लेने के लिए। पहले मामले में, हम मान सकते हैं कि तालिका में तत्व अभी तक संभव नहीं है, और दूसरे में, कि यह सबसे अधिक संभावना पहले से ही वहां है। पिछले ट्रोव कार्यान्वयन में, दोनों खोज विकल्पों में, यह सबसे पहले जांचा जाता है कि क्या सेल खाली है, और फिर क्या हम वहां झूठ की तलाश कर रहे हैं। यद्यपि "ले" की खोज में यह जांचना आवश्यक है कि वर्तमान तत्व वांछित एक के बराबर नहीं है (हाँ यह है)।

इस दो-लाइन परिवर्तन ने IntHashSet.contains(int) 5 ns से त्वरित किया।

जेएमएच पर आम तौर पर बेंचमार्क लिखने का एक और प्रयास

CharHashSet पर CharHashSet , फैक्टर 0.5 भरें, तालिका स्मृति में लगभग 4 KB लेती है। विवरण छोड़ा गया:

  @GenerateMicroBenchmark public char charSet_simple(CharSetState state) { char sum = 0; TCharIterator it = state.iterator; while (it.hasNext()) { sum += it.nextChar(); } return sum; } @GenerateMicroBenchmark public char charSet_forEachLoop(CharSetState state) { char sum = 0; for (char v : state) { sum += v; } return sum; } public static class CharSum implements CharConsumer { public char sum; public void accept( char b ) { sum += b; } } @GenerateMicroBenchmark public char charSet_forEachFunction(CharSetState state) { CharSum procedure = new CharSum(); state.set.forEach( procedure ); return procedure.sum; } @GenerateMicroBenchmark public char charSet_tryAdvance(CharSetState state) { char sum = 0; TCharIterator it = state.iterator; while (it.tryAdvance()) { sum += it.charValue(); } return sum; } 

परिणाम:

  Mean Mean error charSet_forEachFunction 6,7 1,1 nsec/iter charSet_forEachLoop 15,4 2,1 nsec/iter charSet_simple 8,7 0,1 nsec/iter charSet_tryAdvance 8,6 0,1 nsec/iter 

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

"सरल" विधि ट्रोव के पिछले संस्करण के समान संस्करण की तुलना में लगभग 30% अधिक तेज है, इस तथ्य के कारण कि प्रत्येक पुनरावृत्ति पर अगले तत्व को 2 बार खोजा गया: hasNext() विधि और फिर next() विधि दोनों में। अब अगले तत्व का सूचकांक पुनरावृत्ति वर्ग के क्षेत्र में संग्रहीत किया जाता है।

यह सब क्यों

जैसा कि मैंने कहा, मेरे पास पुस्तकालय समाप्त करने के लिए बिल्कुल समय नहीं है:
कोई लिस्टिंग नहीं ( CharArrayList )
सभी वर्गों से अस्थायी रूप से हटाए जाने वाले सीरियल समर्थन
लगभग कोई दस्तावेज नहीं है, केवल जावा 8 से थोड़ी कॉपी पेस्ट है।

लेकिन, चूंकि नई रूपरेखा मानक एक के अनुरूप है, इसलिए वास्तविक कार्यों पर इसका परीक्षण करना बहुत सरल है, खासकर यदि आपने विवेकपूर्ण रूप से लिखा है

 Map<Integer, Long> map = new HashMap<>(); 

हालाँकि मैंने नई लाइब्रेरी को जावा 7u25 के अलावा किसी भी चीज़ के साथ संकलित करने की कोशिश नहीं की है, यह स्रोत (और विधानसभा) द्वारा जावा 6 के साथ संगत होना चाहिए।

रिपॉजिटरी में Intellij के तहत विकास के लिए बहुत पत्तेदार बंधन शामिल है: bitbucket.org/leventov/troet/rc

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

अंग्रेजी में मूल - (अपेक्षित) चर्चा के संदर्भ में।