缓存技术内部交流_05_Cache Through
参考资料：
http://www.ehcache.org/documentation/3.2/caching-patterns.html
http://www.ehcache.org/documentation/3.2/writers.html
示例代码：
https://github.com/gordonklg/study，cache module
A. Cache-As-SoR
前文提过 Cache-As-SoR 模式。老外抽象概念的能力比较泛滥，简而言之，Cache-As-SoR 意味着使用者把缓存层当做系统数据层用，为了同步数据，读模式有 read-through，写模式有 write-through 和 write-behind，读写模式中各取一个组合成 Cache-As-SoR 模式。而文章标题中的 Cache Through 是指 read-through 和 write-through 的组合。
在 Read-Through 模式中，缓存拥有一个 loader 模块，当应用系统访问缓存层获取数据时，如果数据当下不在缓存中，则由 loader 负责从 SoR 获取数据，放入缓存，并返回给应用系统。
在 Write-Through 模式中，当应用系统更新缓存层数据时，由 writer 模块将数据写入 SoR，并更新缓存。
在 Write-Behind 模式中，更新的数据会先存放在本地队列，然后批量写入 SoR。
B. Ehcache3 实现 Cache Through 模式
Ehcache3 通过 CacheLoaderWriter 来实现 Cache-As-SoR 模式，相当于把 loader 和 writer 模块合到了一起。见下例：
gordon.study.cache.ehcache3.pattern.CacheThroughUserService.java
private UserManagedCache<String, UserModel> cache;
public CacheThroughUserService() {
cache = UserManagedCacheBuilder.newUserManagedCacheBuilder(String.class, UserModel.class).withLoaderWriter(new CustomLoaderWriter())
.build(true);
}
public UserModel findUser(String id) {
UserModel result = cache.get(id);
if (result == null) {
System.out.println("can't find user in cache!");
} else {
System.out.println("get user from cache: " + id);
}
return result;
}
public UserModel updateUser(String id, String info) {
UserModel user = new UserModel(id, info);
cache.put(id, user);
return user;
}
public boolean deleteUser(String id) {
cache.remove(id);
return true;
}
public static void main(String[] args) throws Exception {
final CacheThroughUserService service = new CacheThroughUserService();
ExecutorService executorService = Executors.newFixedThreadPool(30);
for (int i = 0; i < 3; i++) {
executorService.execute(new Runnable() {
public void run() {
service.findUser("1");
}
});
executorService.execute(new Runnable() {
public void run() {
service.findUser("2");
}
});
executorService.execute(new Runnable() {
public void run() {
service.findUser("3");
}
});
}
executorService.shutdown();
executorService.awaitTermination(5, TimeUnit.SECONDS);
System.out.println("---------------------------------");
service.updateUser("1", "new info ...");
service.findUser("1");
service.deleteUser("1");
service.findUser("1");
}
private static class CustomLoaderWriter implements CacheLoaderWriter<String, UserModel> {
@Override
public UserModel load(String key) throws Exception {
System.out.println("::load user by id: " + key);
Thread.sleep(1000);
if (key == null || key.equals("1")) {
return new NullUser();
}
return new UserModel(key, "info ...");
}
@Override
public Map<String, UserModel> loadAll(Iterable<? extends String> keys) throws BulkCacheLoadingException, Exception {
System.out.println("::load user by ids: " + keys);
return null;
}
@Override
public void write(String key, UserModel value) throws Exception {
System.out.println("::update user by id: " + key);
}
@Override
public void writeAll(Iterable<? extends Entry<? extends String, ? extends UserModel>> entries)
throws BulkCacheWritingException, Exception {
System.out.println("::update user by ids");
}
@Override
public void delete(String key) throws Exception {
System.out.println("::delete user by id: " + key);
}
@Override
public void deleteAll(Iterable<? extends String> keys) throws BulkCacheWritingException, Exception {
System.out.println("::delete user by ids");
}
}
代码第58行定义的 CustomLoaderWriter 实现了 CacheLoaderWriter 接口。其 load、write、delete 方法分别用于从 SoR 层读取、写入、删除数据。
代码第4行通过 withLoaderWriter 方法设置 loaderWriter，激活 Cache-As-SoR 模式。
Service 层得到极大的精简，只需要无脑操作缓存即可。
从控制台输出可以看出，Cache-As-SoR 比较好的解决了并发读的问题，多个线程有机会同时读取后端数据。
C. 源码分析
CacheLoaderWriter 是如何解决并发读的问题的呢？
首先，要了解 ConcurrentHashMap 有个 compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) 方法，该方法用参数传入的 BiFunction 为指定的 key 设置一个计算出的值，同时保证整个计算过程的原子性：其它线程如果也想更新目标 key 的值，会被阻塞直到 compute 方法完成计算。（实现细节有点难读，需要了解 CAS 原理和 ConcurrentHashMap 设计细节，只看了个大概，以后有机会专门深入研究一下）
剩下的实现就简单了，当 cache builder 指定了 cacheLoaderWriter 时，最终构建的内部 cache 为 EhcacheWithLoaderWriter。EhcacheWithLoaderWriter 的 get 方法最终会调用底层 ConcurrentHashMap 的 compute 方法，通过 CacheLoaderWriter 的 load 方法从 SoR 中获取数据。
为了防止多次调用 CacheLoaderWriter 的 load 方法从 SoR 中获取数据，本来应该要调用 ConcurrentHashMap 的 computeIfAbsent 方法才对。Ehcache3 中把判断 if absent then compute 的逻辑放到了 OnHeapStore 的 computeIfAbsent 方法中，这样做的最大目的应该是为了保证 get 操作会触发过期逻辑。
public ValueHolder<V> computeIfAbsent(final K key, final Function<? super K, ? extends V> mappingFunction) throws StoreAccessException {
computeIfAbsentObserver.begin();
checkKey(key);
final StoreEventSink<K, V> eventSink = storeEventDispatcher.eventSink();
try {
final long now = timeSource.getTimeMillis();
final AtomicReference<OnHeapValueHolder<V>> previousValue = new AtomicReference<OnHeapValueHolder<V>>();
final AtomicReference<StoreOperationOutcomes.ComputeIfAbsentOutcome> outcome =
new AtomicReference<StoreOperationOutcomes.ComputeIfAbsentOutcome>(StoreOperationOutcomes.ComputeIfAbsentOutcome.NOOP);
OnHeapValueHolder<V> computeResult = map.compute(key, new BiFunction<K, OnHeapValueHolder<V>, OnHeapValueHolder<V>>() {
@Override
public OnHeapValueHolder<V> apply(K mappedKey, OnHeapValueHolder<V> mappedValue) {
if (mappedValue == null || mappedValue.isExpired(now, TimeUnit.MILLISECONDS)) {
if (mappedValue != null) {
updateUsageInBytesIfRequired(- mappedValue.size());
fireOnExpirationEvent(mappedKey, mappedValue, eventSink);
}
V computedValue = mappingFunction.apply(mappedKey);
if (computedValue == null) {
return null;
}
checkValue(computedValue);
OnHeapValueHolder<V> holder = newCreateValueHolder(key, computedValue, now, eventSink);
if (holder != null) {
outcome.set(StoreOperationOutcomes.ComputeIfAbsentOutcome.PUT);
updateUsageInBytesIfRequired(holder.size());
}
return holder;
} else {
previousValue.set(mappedValue);
outcome.set(StoreOperationOutcomes.ComputeIfAbsentOutcome.HIT);
OnHeapValueHolder<V> holder = setAccessTimeAndExpiryThenReturnMappingUnderLock(key, mappedValue, now, eventSink);
if (holder == null) {
updateUsageInBytesIfRequired(- mappedValue.size());
}
return holder;
}
}
});
上面第15行代码保证了如果底层 ConcurrentHashMap 中的缓存项已过期，会重新从 SoR 中读取。
