जावा में LRU कैश कार्यांवयन-जावा, multithreading, कैशिंग, मुद्रा, LRU

मैंने निम्नलिखित कोड देखा है, और मुझे लगता है किaddElement विधि के कार्यान्वयन में लूप जबकि बेकार है। आकार + 1 से अधिक तत्व होने के साथ ऐसा कभी नहीं होना चाहिए क्योंकि पहले से ही एक लिखना ताला है। तो जब तक यह स्थिति प्राप्त नहीं हो जाती है तब तक addElement विधि तत्वों को हटा रहा है सच

while(concurrentLinkedQueue.size() >=maxSize)

इसके चारों ओर कोई संकेतक बहुत अच्छा होगा।

कार्यान्वयन यहां दिया गया है:

public class  LRUCache<K,V> {

private  ConcurrentLinkedQueue<K> concurrentLinkedQueue = new ConcurrentLinkedQueue<K>();

private  ConcurrentHashMap<K,V> concurrentHashMap = new ConcurrentHashMap<K, V>();

private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

private Lock readLock = readWriteLock.readLock();

private Lock writeLock = readWriteLock.writeLock();

int maxSize=0;

public LRUCache(final int MAX_SIZE){
this.maxSize=MAX_SIZE;
}

public V getElement(K key){

readLock.lock();
try {
V v=null;
if(concurrentHashMap.contains(key)){
concurrentLinkedQueue.remove(key);
v= concurrentHashMap.get(key);
concurrentLinkedQueue.add(key);
}


return v;
}finally{
readLock.unlock();
}
}

public V removeElement(K key){
writeLock.lock();
try {
V v=null;
if(concurrentHashMap.contains(key)){
v=concurrentHashMap.remove(key);
concurrentLinkedQueue.remove(key);
}

return v;
} finally {
writeLock.unlock();
}
}

public V addElement(K key,V value){
writeLock.lock();
try {
if(concurrentHashMap.contains(key)){
concurrentLinkedQueue.remove(key);
}
while(concurrentLinkedQueue.size() >=maxSize){
K queueKey=concurrentLinkedQueue.poll();
concurrentHashMap.remove(queueKey);
}
concurrentLinkedQueue.add(key);
concurrentHashMap.put(key, value);

return value;
} finally{
writeLock.unlock();
}
}
}

उत्तर:

उत्तर № 1 के लिए 1

यहां बिंदु है, मुझे लगता है कि आपको इसकी आवश्यकता हैजांचें कि क्या एलआरयू अधिकतम आकार है। यहां चेक नहीं है (map.size ()> maxSize), यह "> =" है। अब, आप शायद इसे "if (map.size () से बदल सकते हैं == maxSize) {...} "- जो आदर्श स्थितियों में बिल्कुल वही काम करना चाहिए।

but in not-so-ideal conditions, if for whatever कारण, किसी ने बिना जांच किए मानचित्र में एक अतिरिक्त प्रविष्टि डाली, फिर इस कोड के साथ, नक्शा फिर से आकार में नीचे नहीं जायेगा, क्योंकि यदि स्थिति कभी भी सच नहीं होगी।

तो - "if" और "==" के बजाय "while" और "> =" क्यों नहीं? कोड की एक ही राशि, साथ ही "अप्रत्याशित" स्थितियों के खिलाफ अधिक मजबूत।


जवाब के लिए 0 № 2

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

  • डाल के दौरान, अनावश्यक तत्व को हटा दें।
  • प्राप्त करने के दौरान, तत्व को शीर्ष पर ले जाएं।

आदिम परिचालन एक शॉट होगा। फिर आप इस डेटा संरचना के आस-पास सामान्य सिंक्रनाइज़ या रीड लिन लॉक का उपयोग कर सकते हैं।

जब रीड राइट का उपयोग करते हैं तो पहले जो आता है उस पर निष्पक्षता एलआरयू कैश की तुलना में प्रयुक्त पठन लेखन ताले का मुद्दा है।

यहाँ एक नमूना कार्यान्वयन है।


संबंधित सवाल
सबसे लोकप्रिय