jdk/src/share/classes/java/io/ExpiringCache.java
changeset 11121 4cdbb7f9480f
parent 5506 202f599c92aa
child 14342 8435a30053c1
equal deleted inserted replaced
11120:f8576c769572 11121:4cdbb7f9480f
    33 import java.util.LinkedHashMap;
    33 import java.util.LinkedHashMap;
    34 import java.util.Set;
    34 import java.util.Set;
    35 
    35 
    36 class ExpiringCache {
    36 class ExpiringCache {
    37     private long millisUntilExpiration;
    37     private long millisUntilExpiration;
    38     private Map  map;
    38     private Map<String,Entry> map;
    39     // Clear out old entries every few queries
    39     // Clear out old entries every few queries
    40     private int queryCount;
    40     private int queryCount;
    41     private int queryOverflow = 300;
    41     private int queryOverflow = 300;
    42     private int MAX_ENTRIES = 200;
    42     private int MAX_ENTRIES = 200;
    43 
    43 
    59 
    59 
    60     ExpiringCache() {
    60     ExpiringCache() {
    61         this(30000);
    61         this(30000);
    62     }
    62     }
    63 
    63 
       
    64     @SuppressWarnings("serial")
    64     ExpiringCache(long millisUntilExpiration) {
    65     ExpiringCache(long millisUntilExpiration) {
    65         this.millisUntilExpiration = millisUntilExpiration;
    66         this.millisUntilExpiration = millisUntilExpiration;
    66         map = new LinkedHashMap() {
    67         map = new LinkedHashMap<String,Entry>() {
    67             protected boolean removeEldestEntry(Map.Entry eldest) {
    68             protected boolean removeEldestEntry(Map.Entry<String,Entry> eldest) {
    68               return size() > MAX_ENTRIES;
    69               return size() > MAX_ENTRIES;
    69             }
    70             }
    70           };
    71           };
    71     }
    72     }
    72 
    73 
    97     synchronized void clear() {
    98     synchronized void clear() {
    98         map.clear();
    99         map.clear();
    99     }
   100     }
   100 
   101 
   101     private Entry entryFor(String key) {
   102     private Entry entryFor(String key) {
   102         Entry entry = (Entry) map.get(key);
   103         Entry entry = map.get(key);
   103         if (entry != null) {
   104         if (entry != null) {
   104             long delta = System.currentTimeMillis() - entry.timestamp();
   105             long delta = System.currentTimeMillis() - entry.timestamp();
   105             if (delta < 0 || delta >= millisUntilExpiration) {
   106             if (delta < 0 || delta >= millisUntilExpiration) {
   106                 map.remove(key);
   107                 map.remove(key);
   107                 entry = null;
   108                 entry = null;
   109         }
   110         }
   110         return entry;
   111         return entry;
   111     }
   112     }
   112 
   113 
   113     private void cleanup() {
   114     private void cleanup() {
   114         Set keySet = map.keySet();
   115         Set<String> keySet = map.keySet();
   115         // Avoid ConcurrentModificationExceptions
   116         // Avoid ConcurrentModificationExceptions
   116         String[] keys = new String[keySet.size()];
   117         String[] keys = new String[keySet.size()];
   117         int i = 0;
   118         int i = 0;
   118         for (Iterator iter = keySet.iterator(); iter.hasNext(); ) {
   119         for (String key: keySet) {
   119             String key = (String) iter.next();
       
   120             keys[i++] = key;
   120             keys[i++] = key;
   121         }
   121         }
   122         for (int j = 0; j < keys.length; j++) {
   122         for (int j = 0; j < keys.length; j++) {
   123             entryFor(keys[j]);
   123             entryFor(keys[j]);
   124         }
   124         }