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

LRU कैश को समझना

एक LRU (Least हाल ही में प्रयुक्त) कैश यह निर्धारित करने के लिए आइटम के उपयोग का ट्रैक रखता है कि स्पेस की जरूरत होने पर कौन से डेटा को evict करने के लिए किया जाता है। यह हाल ही में एक्सेस किए गए आइटम को प्राथमिकता देता है, यह सुनिश्चित करता है कि अक्सर इस्तेमाल किए जाने वाले डेटा उपलब्ध हैं।

एक LRU कैश के कोर घटक

एक प्रभावी LRU कैश आम तौर पर दो डेटा संरचनाओं को जोड़ती है:

  • Hash Map: कैश वस्तुओं के लिए तेजी से पहुंच प्रदान करता है।
  • ]] डबली लिंक्ड लिस्ट: आइटम के उपयोग के आदेश को बनाए रखता है, हाल ही में सामने।

कार्यान्वयन चरण

इन चरणों को एक LRU कैश को लागू करने के लिए देखें:

  • हैश मैप और डबल लिंक्ड सूची शुरू करें।
  • डेटा एक्सेस पर, आइटम को सूची के सामने ले जाएं।
  • यदि कैश क्षमता से अधिक है, तो सूची के अंत में आइटम को हटा दें।
  • सम्मिलन और हटाने के दौरान तदनुसार हैश मानचित्र को अपडेट करें।

पायथन में नमूना कार्यान्वयन

यहाँ पाइथन में एक LRU कैश का एक सरल उदाहरण है:

Note: यह कोड ऑर्डर्डडिक्टी के लिए संग्रह मॉड्यूल का उपयोग करता है, जो कार्यान्वयन को सरल बनाता है।

``````````````

संग्रह से आयात OrderedDict

कक्षा LRUCache:

Defeinit

स्वयं कैश = ऑर्डरडडिक्टर ()

आत्म क्षमता =

(स्वयं, कुंजी)

अगर कुंजी स्वयं में नहीं है।

वापसी

स्वयं कैश.move to end(key)

स्वयं वापसी.cache[key]

(स्वयं, कुंजी, मान) को परिभाषित करें:

Self-cache[key] = value

स्वयं कैश.move to end(key)

यदि len(self.cache) > self.capacity:

Self-cache.popitem (last=False)

``````