缓存技术内部交流_03_Cache Aside

参考资料:
http://www.ehcache.org/documentation/3.2/caching-patterns.html
http://www.ehcache.org/documentation/3.2/usermanaged.html(optional)

示例代码:
https://github.com/gordonklg/study,cache module

A. 缓存模式(Caching Patterns)

缓存模式有两种,一种是 Cache Aside,一种是 Cache-As-SoR(system-of-record)。

在 Cache Aside 模式中,应用程序直接操作缓存与系统数据,由应用程序保证缓存的有效性。而在 Cache-As-SoR 模式中,应用程序只能看见缓存,缓存层有自己的 loader 模块,负责与系统数据的交互。

B. Ehcache3 实现 Cache Aside 模式

gordon.study.cache.ehcache3.pattern.CacheAsideUserService.java

    private UserManagedCache<String, UserModel> cache;
 
    public CacheAsideUserService() {
        cache = UserManagedCacheBuilder.newUserManagedCacheBuilder(String.class, UserModel.class).build(true);
    }
 
    public UserModel findUser(String id) {
        UserModel cached = cache.get(id);
        if (cached != null) {
            System.out.println("get user from cache");
            return cached;
        }
        UserModel user = new UserModel(id, "info ..."); // find user
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }
        System.out.println("get user from db");
        cache.put(id, user);
        return user;
    }
 
    public UserModel updateUser(String id, String info) {
        UserModel user = new UserModel(id, info); // update user
        cache.put(id, user);
        return user;
    }
 
    public boolean deleteUser(String id) {
        // delete user
        cache.remove(id);
        return true;
    }
 
    public static void main(String[] args) {
        final CacheAsideUserService service = new CacheAsideUserService();
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                public void run() {
                    service.findUser("1");
                }
            });
        }
        executorService.shutdown();
    }

代码第1行定义了一个 user managed caches,这种 cache 不需要 CacheManager 管理。

findUser 方法首先尝试从缓存中获取数据,如果缓存中没有相应数据,则从 SoR 中获取数据并将之放入缓存。

updateUser 方法修改完 SoR 后会更新缓存中的数据。

deleteUser 方法删除 SoR 中记录后会移除缓存中的数据。

以上就是一个典型的 Cache Aside 示例。

C. Cache Aside 模式的问题:并发读

Cache Aside 模式存在一些问题,第一是并发读的问题,在高并发场景下,当多个请求同时访问一条数据时,如果此时数据不在缓存中(例如刚过期),则这些请求会同时去后端 SoR 中获取数据,瞬间压力巨大。

上面示例代码 main 函数执行时会打印10条 "get user from db",表示所有线程同时访问了后端 SoR。

解决这个问题的办法是引入同步机制,保证只会有一个线程去后端 SoR 中获取数据,其余线程等待数据进入缓存后直接从缓存获取,减轻 SoR 端的压力。

gordon.study.cache.ehcache3.pattern.SyncCacheAsideUserService.java

    private UserManagedCache<String, UserModel> cache;
 
    private final ReentrantLock lock = new ReentrantLock();
 
    public SyncCacheAsideUserService() {
        cache = UserManagedCacheBuilder.newUserManagedCacheBuilder(String.class, UserModel.class).build(true);
    }
 
    public UserModel findUser(String id) {
        UserModel result = cache.get(id);
        if (result == null) {
            lock.lock();
            result = cache.get(id);
            if (result == null) {
                result = new UserModel(id, "info ..."); // find user
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
                System.out.println("get user from db: " + id);
                cache.put(id, result);
            } else {
                System.out.println("get user from cache after competition: " + id);
            }
            lock.unlock();
        } else {
            System.out.println("get user from cache: " + id);
        }
        return result;
    }

    public static void main(String[] args) {
        final SyncCacheAsideUserService service = new SyncCacheAsideUserService();
        ExecutorService executorService = Executors.newFixedThreadPool(30);
        for (int i = 0; i < 10; 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();
    }

通过加锁,保证了只有竞争 lock 成功的线程才能去后端 SoR 获取数据,其它线程只能等待。

从 SyncCacheAsideUserService 的输出发现了新的问题:现在从 SoR 获取数据变成了串行的方式,对不同的 id 的查找操作也被 lock 锁给同步了。

直觉上,我们会想到为每个不同的 id 使用不同的锁。为了查找效率,这些锁需要放置在 Map 结构中,通过 id 为 key 方便检索。最后,由于 id 可取值范围太广,普通的 map 会造成内存泄漏,因此考虑使用 WeakHashMap 解决内存泄漏问题,这样便产生了以下试验性代码(演示用,不要用于生产环境)

gordon.study.cache.ehcache3.pattern.SyncByIdCacheAsideUserService.java

    private UserManagedCache<String, UserModel> cache;
 
    private final Map<String, ReentrantLock> lockMap = new WeakHashMap<>();
 
    private final ReentrantLock lockMapLock = new ReentrantLock();
 
    public SyncByIdCacheAsideUserService() {
        cache = UserManagedCacheBuilder.newUserManagedCacheBuilder(String.class, UserModel.class).build(true);
    }
 
    public UserModel findUser(String id) {
        UserModel result = cache.get(id);
        if (result == null) {
            lockMapLock.lock();
            ReentrantLock lock = lockMap.get(id);
            if (lock == null) {
                lock = new ReentrantLock();
                lockMap.put(new String(id), lock);
            }
            lockMapLock.unlock();
 
            lock.lock();
            result = cache.get(id);
            if (result == null) {
                result = new UserModel(id, "info ..."); // find user
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
                System.out.println("get user from db: " + id);
                cache.put(id, result);
            } else {
                System.out.println("get user from cache after competition: " + id);
            }
            lock.unlock();
        } else {
            System.out.println("get user from cache: " + id);
        }
        return result;
    }

    public static void main(String[] args) throws Exception {
        final SyncByIdCacheAsideUserService service = new SyncByIdCacheAsideUserService();
        ExecutorService executorService = Executors.newFixedThreadPool(30);
        for (int i = 0; i < 10; 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.gc();
        Thread.sleep(1000);
        System.out.println(service.lockMap.size());
    }

D. Cache Aside 模式的问题:并发读写

当读写操作并发存在时,理论上有缓存旧数据的可能。可能场景如下:

  • 线程A读取用户,缓存未命中,于是从 SoR 中读取到旧数据
  • 线程B更新用户,将 SoR 中数据更新,然后更新缓存
  • 线程A将旧数据更新到缓存

但是这种场景仅仅是理论上可能,因为在 SoR 中更新数据一般是比较费时的操作(而且数据库写操作会锁表,读操作必然是要在锁表前读取出旧值的),线程A没理由会在这么长的时间段内没将旧数据更新到缓存。所以一般情况下,我们会无视这种情况。

E. Cache Aside 模式的问题:并发写

并发写也可能导致缓存旧数据。可能场景如下:

  • 线程A更新用户到版本2
  • 线程B更新用户到版本3,然后更新缓存
  • 线程A用版本2的数据更新缓存

同上,这种场景发生概率也很低,尤其是对于用户模块来说,很少有并发写的场景,所以可以不用太考虑,只要设定合适的缓存过期时间就可以了。

不过,解决并发写问题的方法很简单,只要在 update 操作后对缓存执行移除操作而不是更新操作就可以了。

posted @ 2017-07-13 17:40  首夜盲毒预言家  阅读(494)  评论(0编辑  收藏  举报