LruCache

LruCache通过重写LinkedHashMap的removeEldestEntry方法移除最老的元素。

  1. package org.apache.ibatis.cache.decorators;
  3. import java.util.LinkedHashMap;
  4. import java.util.Map;
  5. import java.util.concurrent.locks.ReadWriteLock;
  7. import org.apache.ibatis.cache.Cache;
  9. /**
  10.  * Lru (least recently used) cache decorator
  11.  *
  12.  * @author Clinton Begin
  13.  */
  14. public class LruCache implements Cache {
  16.   private final Cache delegate;
  17.   private Map<Object, Object> keyMap;
  18.   private Object eldestKey;
  20.   public LruCache(Cache delegate) {
  21.     this.delegate = delegate;
  22.     setSize(1024);
  23.   }
  25.   @Override
  26.   public String getId() {
  27.     return delegate.getId();
  28.   }
  30.   @Override
  31.   public int getSize() {
  32.     return delegate.getSize();
  33.   }
  35.   public void setSize(final int size) {
  36.     keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
  37.       private static final long serialVersionUID = 4267176411845948333L;
  39.         //重写LinkedHashMap的removeEldestEntry方法，
  40.         //当数据量超过size时移除最老的元素
  41.       @Override
  42.       protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
  43.         boolean tooBig = size() > size;
  44.         if (tooBig) {
  45.           eldestKey = eldest.getKey();
  46.         }
  47.         return tooBig;
  48.       }
  49.     };
  50.   }
  52.   @Override
  53.   public void putObject(Object key, Object value) {
  54.     delegate.putObject(key, value);
  55.       //同时把key放到keyMap中，并判断是否删除缓存超出的数据
  56.     cycleKeyList(key);
  57.   }
  59.   @Override
  60.   public Object getObject(Object key) {
  61.     keyMap.get(key); //touch
  62.     return delegate.getObject(key);
  63.   }
  65.   private void cycleKeyList(Object key) {
  66.     keyMap.put(key, key);
  67.     if (eldestKey != null) {
  68.         //删除缓存
  69.       delegate.removeObject(eldestKey);
  70.       eldestKey = null;
  71.     }
  72.   }
  74. }

FifoCache

  1. package org.apache.ibatis.cache.decorators;
  3. import java.util.Deque;
  4. import java.util.LinkedList;
  5. import java.util.concurrent.locks.ReadWriteLock;
  7. import org.apache.ibatis.cache.Cache;
  9. /**
  10.  * FIFO (first in, first out) cache decorator
  11.  *
  12.  * @author Clinton Begin
  13.  */
  14. public class FifoCache implements Cache {
  16.   private final Cache delegate;
  17.     //用队列保存缓存顺序
  18.   private final Deque<Object> keyList;
  19.   private int size;
  21.   public FifoCache(Cache delegate) {
  22.     this.delegate = delegate;
  23.     this.keyList = new LinkedList<Object>();
  24.     this.size = 1024;
  25.   }
  27.   @Override
  28.   public void putObject(Object key, Object value) {
  29.       //把key保存到keyList
  30.     cycleKeyList(key);
  31.     delegate.putObject(key, value);
  32.   }
  35.   @Override
  36.   public void clear() {
  37.     delegate.clear();
  38.     keyList.clear();
  39.   }
  41.   private void cycleKeyList(Object key) {
  42.     keyList.addLast(key);
  43.       //缓存个数超出限制，删掉最新进入的
  44.     if (keyList.size() > size) {
  45.       Object oldestKey = keyList.removeFirst();
  46.       delegate.removeObject(oldestKey);
  47.     }
  48.   }
  50. }

BlockingCache

当一个key的值为空的时候，阻塞线程直到key的值被塞进缓存才释放锁，这样也就避免了冲击数据库。

  1. package org.apache.ibatis.cache.decorators;
  3. import java.util.concurrent.ConcurrentHashMap;
  4. import java.util.concurrent.TimeUnit;
  5. import java.util.concurrent.locks.Lock;
  6. import java.util.concurrent.locks.ReadWriteLock;
  7. import java.util.concurrent.locks.ReentrantLock;
  9. import org.apache.ibatis.cache.Cache;
  10. import org.apache.ibatis.cache.CacheException;
  12. /**
  13.  * Simple blocking decorator 
  14.  * 
  15.  * Simple and inefficient version of EhCache's BlockingCache decorator.
  16.  * It sets a lock over a cache key when the element is not found in cache.
  17.  * This way, other threads will wait until this element is filled instead of hitting the database.
  18.  * 
  19.  * @author Eduardo Macarron
  20.  *
  21.  */
  22. public class BlockingCache implements Cache {
  24.   private long timeout;
  25.   private final Cache delegate;
  26.     //每个key都有一把锁
  27.   private final ConcurrentHashMap<Object, ReentrantLock> locks;
  29.   public BlockingCache(Cache delegate) {
  30.     this.delegate = delegate;
  31.     this.locks = new ConcurrentHashMap<Object, ReentrantLock>();
  32.   }
  34.   @Override
  35.   public void putObject(Object key, Object value) {
  36.     try {
  37.       delegate.putObject(key, value);
  38.     } finally {
  39.         //当key的值不为空就释放锁
  40.       releaseLock(key);
  41.     }
  42.   }
  44.   @Override
  45.   public Object getObject(Object key) {
  46.       //先拿到锁
  47.     acquireLock(key);
  48.     Object value = delegate.getObject(key);
  49.     if (value != null) {
  50.         //如果值不为空就释放锁
  51.       releaseLock(key);
  52.     }        
  53.     return value;
  54.   }
  56.   @Override
  57.   public Object removeObject(Object key) {
  58.     // despite of its name, this method is called only to release locks
  59.     releaseLock(key);
  60.     return null;
  61.   }
  64.   //每个key生成一把锁
  65.   private ReentrantLock getLockForKey(Object key) {
  66.     ReentrantLock lock = new ReentrantLock();
  67.     ReentrantLock previous = locks.putIfAbsent(key, lock);
  68.     return previous == null ? lock : previous;
  69.   }
  71.     //如果key的值为空，那么第一个获取key的线程占据锁，
  72.     //其他线程就会阻塞，当设置key不为空时就会释放锁，
  73.     //然后其他线程拿到锁，就可以获取key的值了
  74.   private void acquireLock(Object key) {
  75.     Lock lock = getLockForKey(key);
  76.     if (timeout > 0) {
  77.       try {
  78.         boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
  79.         if (!acquired) {
  80.           throw new CacheException("Couldn't get a lock in " + timeout + " for the key " +  key + " at the cache " + delegate.getId());  
  81.         }
  82.       } catch (InterruptedException e) {
  83.         throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
  84.       }
  85.     } else {
  86.       lock.lock();
  87.     }
  88.   }
  90.   private void releaseLock(Object key) {
  91.     ReentrantLock lock = locks.get(key);
  92.     if (lock.isHeldByCurrentThread()) {
  93.       lock.unlock();
  94.     }
  95.   }
  97. }

SynchronizedCache

SynchronizedCache在每个方法上都有synchronized同步标记，保证同一时刻只有一个线程操作缓存。

  1. /**
  2.  *    Copyright 2009-2017 the original author or authors.
  3.  *
  4.  *    Licensed under the Apache License, Version 2.0 (the "License");
  5.  *    you may not use this file except in compliance with the License.
  6.  *    You may obtain a copy of the License at
  7.  *
  8.  *       http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  *    Unless required by applicable law or agreed to in writing, software
  11.  *    distributed under the License is distributed on an "AS IS" BASIS,
  12.  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  *    See the License for the specific language governing permissions and
  14.  *    limitations under the License.
  15.  */
  16. package org.apache.ibatis.cache.decorators;
  18. import java.util.concurrent.locks.ReadWriteLock;
  20. import org.apache.ibatis.cache.Cache;
  22. /**
  23.  * @author Clinton Begin
  24.  */
  25. public class SynchronizedCache implements Cache {
  27.   private final Cache delegate;
  29.   public SynchronizedCache(Cache delegate) {
  30.     this.delegate = delegate;
  31.   }
  33.   @Override
  34.   public synchronized void putObject(Object key, Object object) {
  35.     delegate.putObject(key, object);
  36.   }
  38.   @Override
  39.   public synchronized Object getObject(Object key) {
  40.     return delegate.getObject(key);
  41.   }
  43.   @Override
  44.   public synchronized Object removeObject(Object key) {
  45.     return delegate.removeObject(key);
  46.   }
  48.   @Override
  49.   public synchronized void clear() {
  50.     delegate.clear();
  51.   }
  53. }

TransactionalCache

TransactionalCache是一个二级缓存事务缓冲区。此类保存会话期间要添加到二级缓存的所有缓存项。调用commit时将条目发送到缓存，如果回滚会话，则丢弃条目。

  1. /**
  2.  *    Copyright 2009-2017 the original author or authors.
  3.  *
  4.  *    Licensed under the Apache License, Version 2.0 (the "License");
  5.  *    you may not use this file except in compliance with the License.
  6.  *    You may obtain a copy of the License at
  7.  *
  8.  *       http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  *    Unless required by applicable law or agreed to in writing, software
  11.  *    distributed under the License is distributed on an "AS IS" BASIS,
  12.  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  *    See the License for the specific language governing permissions and
  14.  *    limitations under the License.
  15.  */
  16. package org.apache.ibatis.cache.decorators;
  18. import java.util.HashMap;
  19. import java.util.HashSet;
  20. import java.util.Map;
  21. import java.util.Set;
  22. import java.util.concurrent.locks.ReadWriteLock;
  24. import org.apache.ibatis.cache.Cache;
  25. import org.apache.ibatis.logging.Log;
  26. import org.apache.ibatis.logging.LogFactory;
  28. /**
  29.  * The 2nd level cache transactional buffer.
  30.  * 
  31.  * This class holds all cache entries that are to be added to the 2nd level cache during a Session.
  32.  * Entries are sent to the cache when commit is called or discarded if the Session is rolled back. 
  33.  * Blocking cache support has been added. Therefore any get() that returns a cache miss 
  34.  * will be followed by a put() so any lock associated with the key can be released. 
  35.  * 
  36.  * @author Clinton Begin
  37.  * @author Eduardo Macarron
  38.  */
  39. public class TransactionalCache implements Cache {
  41.   private static final Log log = LogFactory.getLog(TransactionalCache.class);
  43.   private final Cache delegate;
  44.   private boolean clearOnCommit;
  45.   private final Map<Object, Object> entriesToAddOnCommit;
  46.   private final Set<Object> entriesMissedInCache;
  48.   public TransactionalCache(Cache delegate) {
  49.     this.delegate = delegate;
  50.     this.clearOnCommit = false;
  51.     this.entriesToAddOnCommit = new HashMap<Object, Object>();
  52.     this.entriesMissedInCache = new HashSet<Object>();
  53.   }
  55.   @Override
  56.   public String getId() {
  57.     return delegate.getId();
  58.   }
  60.   @Override
  61.   public int getSize() {
  62.     return delegate.getSize();
  63.   }
  65.   @Override
  66.   public Object getObject(Object key) {
  67.     // issue #116
  68.     Object object = delegate.getObject(key);
  69.     if (object == null) {
  70.       entriesMissedInCache.add(key);
  71.     }
  72.     // issue #146
  73.     if (clearOnCommit) {
  74.       return null;
  75.     } else {
  76.       return object;
  77.     }
  78.   }
  80.   @Override
  81.   public ReadWriteLock getReadWriteLock() {
  82.     return null;
  83.   }
  85.   @Override
  86.   public void putObject(Object key, Object object) {
  87.       //先放在缓存区，提交事务时才会真正放到缓存
  88.     entriesToAddOnCommit.put(key, object);
  89.   }
  91.   @Override
  92.   public Object removeObject(Object key) {
  93.     return null;
  94.   }
  96.     //先清除缓冲区内容，提交事务时才会真正清除缓存
  97.   @Override
  98.   public void clear() {
  99.     clearOnCommit = true;
  100.     entriesToAddOnCommit.clear();
  101.   }
  103.     //提交事务
  104.   public void commit() {
  105.     if (clearOnCommit) {
  106.       delegate.clear();
  107.     }
  108.     flushPendingEntries();
  109.     reset();
  110.   }
  112.   public void rollback() {
  113.     unlockMissedEntries();
  114.     reset();
  115.   }
  117.   private void reset() {
  118.     clearOnCommit = false;
  119.     entriesToAddOnCommit.clear();
  120.     entriesMissedInCache.clear();
  121.   }
  123.   private void flushPendingEntries() {
  124.     for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
  125.       delegate.putObject(entry.getKey(), entry.getValue());
  126.     }
  127.     for (Object entry : entriesMissedInCache) {
  128.       if (!entriesToAddOnCommit.containsKey(entry)) {
  129.         delegate.putObject(entry, null);
  130.       }
  131.     }
  132.   }
  134.   private void unlockMissedEntries() {
  135.     for (Object entry : entriesMissedInCache) {
  136.       try {
  137.         delegate.removeObject(entry);
  138.       } catch (Exception e) {
  139.         log.warn("Unexpected exception while notifiying a rollback to the cache adapter."
  140.             + "Consider upgrading your cache adapter to the latest version.  Cause: " + e);
  141.       }
  142.     }
  143.   }
  145. }

LoggingCache

用于计算缓存命中率。

  1. package org.apache.ibatis.cache.decorators;
  3. import java.util.concurrent.locks.ReadWriteLock;
  5. import org.apache.ibatis.cache.Cache;
  6. import org.apache.ibatis.logging.Log;
  7. import org.apache.ibatis.logging.LogFactory;
  9. /**
  10.  * @author Clinton Begin
  11.  */
  12. public class LoggingCache implements Cache {
  14.   private final Log log;
  15.   private final Cache delegate;
  16.   protected int requests = 0;
  17.   protected int hits = 0;
  20.   @Override
  21.   public Object getObject(Object key) {
  22.       //总的请求数
  23.     requests++;
  24.     final Object value = delegate.getObject(key);
  25.     if (value != null) {
  26.         //缓存命中数
  27.       hits++;
  28.     }
  29.     if (log.isDebugEnabled()) {
  30.         //日志记录缓存命中率
  31.       log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
  32.     }
  33.     return value;
  34.   }
  36.   private double getHitRatio() {
  37.     return (double) hits / (double) requests;
  38.   }
  40. }

装饰器模式

这些缓存通过装饰器组合，可以形成具有很多种功能的缓存。

  1. PerpetualCache cache = new PerpetualCache("id");
  2. //具有lru功能
  3. LruCache lru = new LruCache(cache);
  4. //具有lru和log功能
  5. LoggingCache log = new LoggingCache(lru);
  6. //具有lru和log和同步锁功能
  7. SynchronizedCache sync = new SynchronizedCache(log);