Ehcache BlockingCache 源码分析
BlockingCache是对Ehcache进行的扩展,BlockingCache内置了读写锁，不需要用户显示调用。
要彻底分析BlockingCache的原理，需要首先来看一下它内部用到的一些类。
//锁的管理器接口 public interface CacheLockProvider { /** * 根据key获取锁 * 这个实现需要保证给定相同的key必须返回同一把锁 */ Sync getSyncForKey(Object key); }
public interface StripedReadWriteLock extends CacheLockProvider { /** * 根据key获得Java的ReadWriteLock */ ReadWriteLock getLockForKey(Object key); /** * 获取所有锁 */ List<ReadWriteLockSync> getAllSyncs(); }
上面的俩个接口是用来管理锁的，待会我们再看具体实现，再来看一下锁的接口。
public interface Sync { /** * Acquire lock of LockType.READ or WRITE * @param type the lock type to acquire */ void lock(LockType type); /** * Tries to acquire a LockType.READ or WRITE for a certain period * @param type the lock type to acquire * @param msec timeout * @return true if the lock got acquired, false otherwise * @throws InterruptedException Should the thread be interrupted */ boolean tryLock(LockType type, long msec) throws InterruptedException; /** * Releases the lock held by the current Thread. * In case of a LockType.WRITE, should the lock not be held by the current Thread, nothing happens * @param type the lock type to acquire */ void unlock(LockType type); /** * Returns true is this is lock is held at given level by the current thread. * * @param type the lock type to test * @return true if the lock is held */ boolean isHeldByCurrentThread(LockType type); }
/** * 这个类是Sync接口的实现类，底层用到了Java原生的ReentrantReadWriteLock * ReentrantReadWriteLock是读写锁，不了解的可以先去学习一下这个类的使用方法 * 不然会很难理解,其实ReadWriteLockSync的类的方法都是调用ReentrantReadWriteLock。 */ public class ReadWriteLockSync implements Sync { //Java的读写锁,其实这个类底层都是调用它. private final ReentrantReadWriteLock rrwl; public ReadWriteLockSync() { this(new ReentrantReadWriteLock()); } public ReadWriteLockSync(ReentrantReadWriteLock lock) { this.rrwl = lock; } /** * 根据类型获取锁. */ public void lock(final LockType type) { getLock(type).lock(); } /** * 在给定时间内尝试获取锁. */ public boolean tryLock(final LockType type, final long msec) throws InterruptedException { return getLock(type).tryLock(msec, TimeUnit.MILLISECONDS); } /** * 释放锁. */ public void unlock(final LockType type) { getLock(type).unlock(); } //根据枚举类型获取写入锁OR读取锁. private Lock getLock(final LockType type) { switch (type) { case READ: return rrwl.readLock(); case WRITE: return rrwl.writeLock(); default: throw new IllegalArgumentException("We don't support any other lock type than READ or WRITE!"); } } public ReadWriteLock getReadWriteLock() { return rrwl; } /** * 判断当前线程是否获取了写入锁. */ public boolean isHeldByCurrentThread(LockType type) { switch (type) { case READ: throw new UnsupportedOperationException("Querying of read lock is not supported."); case WRITE: return rrwl.isWriteLockedByCurrentThread(); default: throw new IllegalArgumentException("We don't support any other lock type than READ or WRITE!"); } } }
StripedReadWriteLockSync类是负责管理锁的，会根据传入的key的hash值计算出数组的下标，原理与hashmap一样。
/** * 这个类是锁管理器的实现类，用来管理锁. * 这个类的实现原理就是内部维护一个锁的数组(默认2048个) * 然后根据传入的key通过hash算法获取到一个int类型的值，这个值就是锁数组的下标. * 这样就可以针对不同的key分别锁定提高并发效率 */ public class StripedReadWriteLockSync implements StripedReadWriteLock { /** * 默认锁的数量必须是2的幂 */ public static final int DEFAULT_NUMBER_OF_MUTEXES = 2048; //锁的数组 private final ReadWriteLockSync[] mutexes; //锁的list private final List<ReadWriteLockSync> mutexesAsList; public StripedReadWriteLockSync() { this(DEFAULT_NUMBER_OF_MUTEXES); } /** * 构造函数，初始化锁. */ public StripedReadWriteLockSync(int numberOfStripes) { if ((numberOfStripes & (numberOfStripes - 1)) != 0) { throw new CacheException("Cannot create a CacheLockProvider with a non power-of-two number of stripes"); } if (numberOfStripes == 0) { throw new CacheException("A zero size CacheLockProvider does not have useful semantics."); } //初始化数组. mutexes = new ReadWriteLockSync[numberOfStripes]; //初始化ReadWriteLockSync锁放入数组. for (int i = 0; i < mutexes.length; i++) { mutexes[i] = new ReadWriteLockSync(); } mutexesAsList = Collections.unmodifiableList(Arrays.asList(mutexes)); } /** * 根据key获取锁，相同的key获取到同一把锁。 */ public ReadWriteLockSync getSyncForKey(final Object key) { //根据key的hash算法在与数组的长度计算出数组下标,这个算法会保证得到的int值在0-数组长度之内不会越界. int lockNumber = ConcurrencyUtil.selectLock(key, mutexes.length); return mutexes[lockNumber]; } /** * 根据key获取锁 */ public ReadWriteLock getLockForKey(final Object key) { int lockNumber = ConcurrencyUtil.selectLock(key, mutexes.length); return mutexes[lockNumber].getReadWriteLock(); } /** * Returns all internal syncs * @return all internal syncs */ public List<ReadWriteLockSync> getAllSyncs() { return mutexesAsList; } }
BlockingCache核心代码分析，在使用它的时候有一点需要注意，如果一个线程get方法获取element，当获取不到时会返回null，这时线程并没有释放写入锁，这点一定要注意。
所以必须要调用blockingCache.put(new Element(key, null)) 来释放锁。
/** * A blocking decorator for an Ehcache, backed by a {@link Ehcache}. */ public class BlockingCache extends EhcacheDecoratorAdapter { /** * The amount of time to block a thread before a LockTimeoutException is thrown */ protected volatile int timeoutMillis; private final int stripes; //线程安全的引用AtomicReference private final AtomicReference<CacheLockProvider> cacheLockProviderReference; private final OperationObserver<GetOutcome> getObserver = operation(GetOutcome.class).named("get").of(this).tag("blocking-cache").build(); /** * Creates a BlockingCache which decorates the supplied cache. */ public BlockingCache(final Ehcache cache, int numberOfStripes) throws CacheException { super(cache); this.stripes = numberOfStripes; this.cacheLockProviderReference = new AtomicReference<CacheLockProvider>(); } /** * Creates a BlockingCache which decorates the supplied cache. */ public BlockingCache(final Ehcache cache) throws CacheException { this(cache, StripedReadWriteLockSync.DEFAULT_NUMBER_OF_MUTEXES); } private CacheLockProvider getCacheLockProvider() { CacheLockProvider provider = cacheLockProviderReference.get(); while (provider == null) { cacheLockProviderReference.compareAndSet(null, createCacheLockProvider()); provider = cacheLockProviderReference.get(); } return provider; } //初始化StripedReadWriteLockSync private CacheLockProvider createCacheLockProvider() { Object context = underlyingCache.getInternalContext(); if (underlyingCache.getCacheConfiguration().isTerracottaClustered() && context != null) { return (CacheLockProvider) context; } else { return new StripedReadWriteLockSync(stripes); } } /** * Retrieve the EHCache backing cache */ protected Ehcache getCache() { return underlyingCache; } /** * 获取元素 */ @Override public Element get(final Object key) throws RuntimeException, LockTimeoutException { getObserver.begin(); //通过key获取锁,不同的key在大多数情况获取的锁都是不同的，所以性能会很好. Sync lock = getLockForKey(key); //获取读取锁,读取锁是可以并发读的，所以效率会很好. acquiredLockForKey(key, lock, LockType.READ); Element element; try { //在真正的cache里获取元素 element = underlyingCache.get(key); } finally { //释放读取锁 lock.unlock(LockType.READ); } //如果元素为空，则获取写入锁，写入锁不可以并发进入的。 if (element == null) { acquiredLockForKey(key, lock, LockType.WRITE); //再次获取元素,如果为空则直接返回，注意当前线程并没有释放锁.这里一定要注意。 element = underlyingCache.get(key); if (element != null) { //如果元素不为空,说明已经有线程在其它时刻put进去元素了,那么直接释放锁就OK了。 lock.unlock(LockType.WRITE); getObserver.end(GetOutcome.HIT); } else { getObserver.end(GetOutcome.MISS_AND_LOCKED); } return element; } else { getObserver.end(GetOutcome.HIT); return element; } } private void acquiredLockForKey(final Object key, final Sync lock, final LockType lockType) { if (timeoutMillis > 0) { try { //如果设置了超时时间,那么在给定时间内获取不到锁就抛异常. boolean acquired = lock.tryLock(lockType, timeoutMillis); if (!acquired) { StringBuilder message = new StringBuilder("Lock timeout. Waited more than ") .append(timeoutMillis) .append("ms to acquire lock for key ") .append(key).append(" on blocking cache ").append(underlyingCache.getName()); throw new LockTimeoutException(message.toString()); } } catch (InterruptedException e) { throw new LockTimeoutException("Got interrupted while trying to acquire lock for key " + key, e); } } else { //获取锁,获取不到就会一直等待知道获取到锁。 lock.lock(lockType); } } protected Sync getLockForKey(final Object key) { return getCacheLockProvider().getSyncForKey(key); } /** * put元素自动释放锁,主要看doAndReleaseWriteLock. */ @Override public void put(final Element element) { doAndReleaseWriteLock(new PutAction<Void>(element) { @Override public Void put() { if (element.getObjectValue() != null) { underlyingCache.put(element); } else { underlyingCache.remove(element.getObjectKey()); } return null; } }); } private <V> V doAndReleaseWriteLock(PutAction<V> putAction) { if (putAction.element == null) { return null; } Object key = putAction.element.getObjectKey(); //根据key获取锁. Sync lock = getLockForKey(key); //判断一下当前线程是否已经获取了写入锁,如果已经获取到锁，那么说明当前线程是执行get方法是元素为null时获取到锁的. //否则说明是另一个新的线程直接调用put的方法，所以需要重新获取锁. if (!lock.isHeldByCurrentThread(LockType.WRITE)) { lock.lock(LockType.WRITE); } try { return putAction.put(); } finally { //在这里释放锁. lock.unlock(LockType.WRITE); } } private abstract static class PutAction<V> { private final Element element; private PutAction(Element element) { this.element = element; } abstract V put(); } }