~~~ package org.apache.ibatis.cache.decorators; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import org.apache.ibatis.cache.Cache; import org.apache.ibatis.cache.CacheException; /** * Simple blocking decorator * * Simple and inefficient version of EhCache's BlockingCache decorator. * It sets a lock over a cache key when the element is not found in cache. * This way, other threads will wait until this element is filled instead of hitting the database. * * @author Eduardo Macarron * */ public class BlockingCache implements Cache { //超時時間 private long timeout; //緩存實體 private final Cache delegate; //可重入鎖 private final ConcurrentHashMap<Object, ReentrantLock> locks; //構造器 public BlockingCache(Cache delegate) { this.delegate = delegate; this.locks = new ConcurrentHashMap<>(); } //獲取id @Override public String getId() { return delegate.getId(); } //獲取長度 @Override public int getSize() { return delegate.getSize(); } //放入數據，并釋放鎖 @Override public void putObject(Object key, Object value) { try { delegate.putObject(key, value); } finally { releaseLock(key); } } //獲取對象，并釋放鎖 @Override public Object getObject(Object key) { acquireLock(key); Object value = delegate.getObject(key); if (value != null) { releaseLock(key); } return value; } //刪除對象，并釋放鎖 @Override public Object removeObject(Object key) { // despite of its name, this method is called only to release locks releaseLock(key); return null; } //清除數據 @Override public void clear() { delegate.clear(); } //根據key獲取對應的鎖，一個對象一個鎖 private ReentrantLock getLockForKey(Object key) { return locks.computeIfAbsent(key, k -> new ReentrantLock()); } //獲取對象的鎖 private void acquireLock(Object key) { Lock lock = getLockForKey(key); if (timeout > 0) { try { boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS); if (!acquired) { throw new CacheException("Couldn't get a lock in " + timeout + " for the key " + key + " at the cache " + delegate.getId()); } } catch (InterruptedException e) { throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e); } } else { lock.lock(); } } //釋放鎖 private void releaseLock(Object key) { ReentrantLock lock = locks.get(key); //判斷是否被當前線程持有 if (lock.isHeldByCurrentThread()) { lock.unlock(); } } //獲取超時時間-毫秒 public long getTimeout() { return timeout; } //設置超時時間-毫秒 public void setTimeout(long timeout) { this.timeout = timeout; } } ~~~