自定义缓存实现ConcurrentHashMap

import   java.util.Map; import   java.util.WeakHashMap; import   java.util.concurrent.ConcurrentHashMap; import   java.util.concurrent.locks.Lock; import   java.util.concurrent.locks.ReentrantLock;   public   class   SimpleCache<K,V> {             private   final   Lock   lock = new   ReentrantLock();       private   final   int   maxCapacity ;       //最大存储能力       private   final   Map<K,V>   eden ;         //边界缓存or临时缓存       private   final   Map<K,V>   longterm ;     //长久缓存 当 对象不使用时会被虚拟机gc()的             public   SimpleCache(   int   maxCapacity){                           this .   maxCapacity =maxCapacity;               this .   eden =   new   ConcurrentHashMap<K, V>(maxCapacity);               this .   longterm =   new   WeakHashMap<K,V>(maxCapacity);                  }       //清空缓存中某个key和value先清空缓存中的值然后清除固定缓存中的值       public   void   deleteKey(K k){                           if (   null !=   this .get(k)){                                     this . doDel(k);                             }                              }       public   void   doDel (K k){                           this .   eden .remove(k);               if (   null !=   this .   longterm .get(k)){                                     this .   longterm .remove(k);                             }                  }       //根据某Key获取相对应的值，先从临时缓存中查找，若不存在则去固定缓存中查找，若存在则将查到的值放入到临时缓存中       public   V get(K k){            V v= this . eden .get(k);       if (v== null ){               lock .lock();               try {            v=   this .   longterm .get(k);                        }   finally {                                     lock .unlock();                             }               if (v!=   null ){                                     this .   eden .put(k, v);                             }      }       return   v;     }       //将值放入临时缓存中，若临时缓存溢出，则将临时缓存中全部取出放入固定缓存中，同时清空临时缓存，并将新加入的值放入临时缓存中       public   void   put(K k,V v){             if ( this . eden .size()>= maxCapacity ){                           lock .lock();               try {                                     this .   longterm .putAll(   this .   eden );                             }   finally {                                     lock .unlock();                             }                           this .   eden .clear();      }       this . eden .put(k, v);     }     } /// 实现类 public   class   MyCache   extends   SimpleCache<String, Object> {         public   MyCache(   int   maxCapacity) {                           super (maxCapacity);                  }             public   static   void   main(String[] args) {                        MyCache myCache=   new   MyCache(10);            myCache.put(   "1" , 123);            System.   out .print(myCache.get(   "1" ));            myCache.deleteKey(   "1" );            System.   out .println(myCache.get(   "1" ));      } }

 

转载于:https://www.cnblogs.com/beantestng/p/3772841.html