google guava cache 处理

使用本地内存

Java代码  收藏代码
  1. LoadingCache<Long, User> cache = CacheBuilder.newBuilder().maximumSize(100)  
  2.                 .expireAfterAccess(5, TimeUnit.SECONDS).build(new CacheLoader<Long, User>() {  
  3.                     @Override  
  4.                     public User load(Long key) throws Exception {  
  5.                         logger.info("fetch from database");  
  6.                         return accountManager.getUser(key);  
  7.                     }  
  8.   
  9.                 });  
 

//设置缓存最大个数为100,缓存过期时间为5秒

 

回收的参数设置

 

1. 大小的设置:CacheBuilder.maximumSize(long) CacheBuilder.weigher(Weigher) CacheBuilder.maxumumWeigher(long)

2. 时间:expireAfterAccess(long, TimeUnit) expireAfterWrite(long, TimeUnit)

3. 引用:CacheBuilder.weakKeys() CacheBuilder.weakValues() CacheBuilder.softValues()

4. 明确的删除:invalidate(key) invalidateAll(keys) invalidateAll()

5. 删除监听器:CacheBuilder.removalListener(RemovalListener)

 

refresh机制

 

1. LoadingCache.refresh(K) 在生成新的value的时候,旧的value依然会被使用。

2. CacheLoader.reload(K, V) 生成新的value过程中允许使用旧的value

3. CacheBuilder.refreshAfterWrite(long, TimeUnit) 自动刷新cache

 

 

类似ConcurrentMap, 数据存在内存而不是file,外部server, 否则可以用memcached(待会儿解释)

如果value是通过正常的func使用key来得到的,那么可以使用CacheLoader,如果需要override,那么使用Callable

正常的使用方法是, LoadingCache.get(K), 将会查询cache,如果cache没有,那么会CacheLoader会将value加入cache,

注意的是,CacheLoader可能会抛出异常,所以如果你的LoadingCache中没有处理异常的话,那么最好使用 getUnchecked(K)方法

getAll(Iterable<? extends K>) 方法可以 批读取, 也是分成一个个key来处理,但是肯定比手工的效率更高, 可以通过override CacheLoader.loadAll 来更好的处理

 

get(K, Callable<V>), 这个方法实现了if cached, return; otherwise create, cache and return 模式

即如果cache了返回,如果没有通过callable接口的方法来create,然后cache,最后返回

Java代码  收藏代码
  1. Cache<Key, Value> cache = CacheBuilder.newBuilder()  
  2.     .maximumSize(1000)  
  3.     .build(); // look Ma, no CacheLoader  
  4. ...  
  5. try {  
  6.   // If the key wasn't in the "easy to compute" group, we need to  
  7.   // do things the hard way.  
  8.   cache.get(key, new Callable<Value>() {  
  9.     @Override  
  10.     public Value call() throws AnyException {  
  11.       return doThingsTheHardWay(key);  
  12.     }  
  13.   });  
  14. catch (ExecutionException e) {  
  15.   throw new OtherException(e.getCause());  
  16. }  
 

直接操作cache

使用cache.put(key,value), 同时可以使用Cache.asMap()来调用所以ConcurrentMap的方法来操作cache,但是通过asMap的数据不会自动loading到cache

 

三种清出cache的模式size-based eviction, time-based eviction, and reference-based eviction.

size-based:

Java代码  收藏代码
  1. LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()  
  2.        .maximumWeight(100000)  
  3.        .weigher(new Weigher<Key, Graph>() {  
  4.           public int weigh(Key k, Graph g) {  
  5.             return g.vertices().size();  
  6.           }  
  7.         })  
  8.        .build(  
  9.            new CacheLoader<Key, Graph>() {  
  10.              public Graph load(Key key) { // no checked exception  
  11.                return createExpensiveGraph(key);  
  12.              }  
  13.            });  
 

weigher,作用是将g.vertices().size()作为一个单位大小,重载此方法, 同时是在cache创建的时候计算

 

time-based:

expireAfterAccess(long, TimeUnit)  基于访问(read or write)

expireAfterWrite(long, TimeUnit) 基于创建(after create)

 

reference-based

CacheBuilder.weakKeys(), 使用weak references来建立key,这样的话如果key没有引用了(strong or soft),key就会被垃圾回收,同时垃圾回收使用==来判断key值

CacheBuilder.weakValues(),  同上,作用到value上

CacheBuilder.softValues() , 对value进行排序,

 

主动清出cache

Cache.invalidate(key)

 Cache.invalidateAll(keys)

  Cache.invalidateAll()

 

 

clearUp,  cache不会自己clearup,一般需要通过线程定制,定时的clearup

 

refresh 操作, 与evict不同, 是给key一个new value, 同时如果在refresh时有访问,那么将会返回old value, 而evict则会等待evict结束返回new value

定义refresh一般使用异步的操作

如:

Java代码  收藏代码
  1. // Some keys don't need refreshing, and we want refreshes to be done asynchronously.  
  2. LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()  
  3.        .maximumSize(1000)  
  4.        .refreshAfterWrite(1, TimeUnit.MINUTES)  
  5.        .build(  
  6.            new CacheLoader<Key, Graph>() {  
  7.              public Graph load(Key key) { // no checked exception  
  8.                return getGraphFromDatabase(key);  
  9.              }  
  10.   
  11.              public ListenableFuture<Graph> reload(final Key key, Graph prevGraph) {  
  12.                if (neverNeedsRefresh(key)) {  
  13.                  return Futures.immediateFuture(prevGraph);  
  14.                } else {  
  15.                  // asynchronous!  
  16.                  return ListenableFutureTask.create(new Callable<Graph>() {  
  17.                    public Graph call() {  
  18.                      return getGraphFromDatabase(key);  
  19.                    }  
  20.                  });  
  21.                }  
  22.              }  
  23.            });  
 

 

 在refreshAfterWrite方法,会调用reload

 

数据

  提供了一些数据采集的方法

   CacheBuilder.recordStats() 方法启动了 cache的数据收集

    Cache.stats() 返回了一个CacheStats对象, 提供一些数据方法

    hitRate(), 请求点击率

    averageLoadPenalty(), 加载new value,花费的时间, 单位nanosecondes

    evictionCount(), 清除的个数

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页