Google Guava之--cache

转载 2016年05月30日 15:12:02

一、简介
  Google Guava包含了Google的Java项目许多依赖的库,如:集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O 等等。本文只介绍其中的缓存部分。
  Guava Cache是一种本地缓存实现,支持多种缓存过期策略。性能好,简单易用。缓存在很多场景下都是很有用的。如,通过key获取一个value的花费的时间很多,而且获取的次数不止一次的时候,就应该考虑使用缓存。Guava Cache与ConcurrentMap很相似,但也不完全一样。最基本的区别是ConcurrentMap会一直保存所有添加的元素,直到显式地移除。而Guava Cache为了限制内存占用,通常都设定为自动回收元素。在某些场景下,尽管LoadingCache 不回收元素,它也会自动加载缓存。

  Guava Cache适用于以下应用场景:

  • 系统的访问速度首要考虑,而内存空间为次要考虑。
  • 某些key对于的value会被查询多次。
  • 缓存中存放的数据总量不会超出内存的全部大小。

本文例子使用的guava 版本为guava-18.0.jar,下载地址如下:
http://central.maven.org/maven2/com/google/guava/guava/18.0/guava-18.0.jar

二、Cache使用方式

  1、CacheLoader方式

  代码如下:

 1 import java.util.ArrayList;

 2 import java.util.List;

 3 import java.util.concurrent.ExecutionException;

 4 import java.util.concurrent.TimeUnit;

 5 

 6 import org.junit.Test;

 7 

 8 import com.google.cacahe.Person;

 9 import com.google.common.cache.CacheBuilder;

10 import com.google.common.cache.CacheLoader;

11 import com.google.common.cache.LoadingCache;

12 

13 public class TestGuavaCache {

14 

15     @Test

16     public void testUserCacheLoader() throws ExecutionException {

17         // 模拟数据

18         final List<Person> list = new ArrayList<Person>(5);

19         list.add(new Person("1", "zhangsan"));

20         list.add(new Person("2", "lisi"));

21         list.add(new Person("3", "wangwu"));

22 

23         // 创建cache

24         LoadingCache<String, Person> cache = CacheBuilder.newBuilder()//

25                 .refreshAfterWrite(1, TimeUnit.MINUTES)// 给定时间内没有被读/写访问,则回收。

26                 // .expireAfterWrite(5, TimeUnit.SECONDS)//给定时间内没有写访问,则回收。

27                 // .expireAfterAccess(3, TimeUnit.SECONDS)// 缓存过期时间为3秒

28                 .maximumSize(100).// 设置缓存个数

29                 build(new CacheLoader<String, Person>() {

30                     @Override

31                     /**  当本地缓存命没有中时,调用load方法获取结果并将结果缓存

32                      */

33                     public Person load(String key) throws ExecutionException {

34                         System.out.println(key + " load in cache");

35                         return getPerson(key);

36                     }

37 

38                     // 此时一般我们会进行相关处理,如到数据库去查询

39                     private Person getPerson(String key) throws ExecutionException {

40                         System.out.println(key + " query");

41                         for (Person p : list) {

42                             if (p.getId().equals(key))

43                                 return p;

44                         }

45                         return null;

46                     }

47                 });

48 

49         cache.get("1");

50         cache.get("2");

51         cache.get("3");

52         System.out.println("======= sencond time  ==========");

53         cache.get("1");

54         cache.get("2");

55         cache.get("3");

56     }

57 }

  执行结果如下:

1 load in cache

1 query

2 load in cache

2 query

3 load in cache

3 query

======= sencond time  ==========

  第二次获取的时候没有执行获取的方法,而是直接从缓存中获取。

  2、Callback方式

  代码如下:

 1 import java.util.ArrayList;

 2 import java.util.List;

 3 import java.util.concurrent.Callable;

 4 import java.util.concurrent.ExecutionException;

 5 

 6 import org.junit.Test;

 7 

 8 import com.google.cacahe.Person;

 9 import com.google.common.cache.Cache;

10 import com.google.common.cache.CacheBuilder;

11 

12 public class TestGuavaCache {

13     

14 

15     @Test

16     public void testUserCallback() throws ExecutionException {

17         // 模拟数据

18         final List<Person> list = new ArrayList<Person>(5);

19         list.add(new Person("1", "zhangsan"));

20         list.add(new Person("2", "lisi"));

21         list.add(new Person("3", "wangwu"));

22 

23         final String key = "1";

24         Cache<String, Person> cache2 = CacheBuilder.newBuilder().maximumSize(1000).build();

25         /**

26          * 用缓存中的get方法,当缓存命中时直接返回结果;否则,通过给定的Callable类call方法获取结果并将结果缓存。<br/>

27          * 可以用一个cache对象缓存多种不同的数据,只需创建不同的Callable对象即可。

28          */

29         Person person = cache2.get(key, new Callable<Person>() {

30             public Person call() throws ExecutionException {

31                 System.out.println(key + " load in cache");

32                 return getPerson(key);

33             }

34 

35             // 此时一般我们会进行相关处理,如到数据库去查询

36             private Person getPerson(String key) throws ExecutionException {

37                 System.out.println(key + " query");

38                 for (Person p : list) {

39                     if (p.getId().equals(key))

40                         return p;

41                 }

42                 return null;

43             }

44         });

45         System.out.println("======= sencond time  ==========");

46         person = cache2.getIfPresent(key);

47         person = cache2.getIfPresent(key);

48     }

49 }

  执行结果如下:

1 load in cache

1 query

======= sencond time  ==========

  第二次获取后也是直接从缓存中加载。

  3、关于移除监听器

  通过CacheBuilder.removalListener(RemovalListener),我们可以声明一个监听器,从而可以在缓存被移除时做一些其他的操作。当缓存被移除时,RemovalListener会获取移除bing通知[RemovalNotification],其中包含移除的key、value和RemovalCause。

  示例代码如下:

 1 import java.util.concurrent.ExecutionException;

 2 import java.util.concurrent.TimeUnit;

 3 

 4 import org.junit.Test;

 5 

 6 import com.google.cacahe.Person;

 7 import com.google.common.cache.CacheBuilder;

 8 import com.google.common.cache.CacheLoader;

 9 import com.google.common.cache.LoadingCache;

10 import com.google.common.cache.RemovalListener;

11 import com.google.common.cache.RemovalNotification;

12 

13 public class TestGuavaCache {

14     @Test

15     public void testListener() throws ExecutionException {

16         CacheLoader<String, Person> loader = new CacheLoader<String, Person>() {

17             @Override

18             // 当本地缓存命没有中时,调用load方法获取结果并将结果缓存

19             public Person load(String key) throws ExecutionException {

20                 System.out.println(key + " load in cache");

21                 return getPerson(key);

22             }

23             // 此时一般我们会进行相关处理,如到数据库去查询

24             private Person getPerson(String key) throws ExecutionException {

25                 System.out.println(key + " query");

26                 return new Person(key, "zhang" + key);

27             }

28         };

29 

30         // remove listener

31         RemovalListener<String, Person> removalListener = new RemovalListener<String, Person>() {

32             public void onRemoval(RemovalNotification<String, Person> removal) {

33                 System.out.println("cause:" + removal.getCause() + " key:" + removal.getKey() + " value:"

34                         + removal.getValue());

35             }

36         };

37 

38         LoadingCache<String, Person> cache = CacheBuilder.newBuilder()//

39                 .expireAfterWrite(2, TimeUnit.MINUTES).maximumSize(1024).removalListener(removalListener).build(loader);

40         cache.get("1");// 放入缓存

41         cache.get("1");// 第二次获取(此时从缓存中获取)

42         cache.invalidate("1");// 移除缓存

43         cache.get("1");// 重新获取

44         cache.get("1");// 再次获取(此时从缓存中获取)

45     }

46 }

  运行结果如下:

1 1 load in cache

2 1 query

3 cause:EXPLICIT key:1 value:Person [id=1, name=zhang1]

4 1 load in cache

5 1 query

 三、其他相关方法

  显式插入:该方法可以直接向缓存中插入值,如果缓存中有相同key则之前的会被覆盖。

cache.put(key, value);

  显式清除:我们也可以对缓存进行手动清除。

cache.invalidate(key); //单个清除

cache.invalidateAll(keys); //批量清除

cache.invalidateAll(); //清除所有缓存项

  基于时间的移除: 

expireAfterAccess(long, TimeUnit); 该键值对最后一次访问后超过指定时间再移除

expireAfterWrite(long, TimeUnit) ;该键值对被创建或值被替换后超过指定时间再移除

  基于大小的移除:指如果缓存的对象格式即将到达指定的大小,就会将不常用的键值对从cache中移除。

cacheBuilder.maximumSize(long)

   size是指cache中缓存的对象个数。当缓存的个数开始接近size的时候系统就会进行移除的操作

  缓存清除执行的时间

  使用CacheBuilder构建的缓存不会"自动"执行清理和回收工作,也不会在某个缓存项过期后马上清理,也没有诸如此类的清理机制。它是在写操作时顺带做少量的维护工作(清理);如果写操作太少,读操作的时候也会进行少量维护工作。因为如果要自动地持续清理缓存,就必须有一个线程,这个线程会和用户操作竞争共享锁。在某些环境下线程创建可能受限制,这样CacheBuilder就不可用了。


原文地址:http://www.csdn123.com/html/topnews201408/78/5978.htm

相关文章推荐

Google Guava Cache 示列

google guava cache引用maven依赖 com.google.guava guava 18.0

google Guava Cache使用

前言 项目中需要按照时间维度定期清理map中的数据,清理数据时还需要有个回调能够做点其他事情,此场景使用Guava Cache非常合适,因此对Guava Cache做个总结。在多线程高并发场景中往往是...

Google Guava 工具集__2__Cache 缓存使用

范例 01 LoadingCache graphs = CacheBuilder.newBuilder() 02    ...

Guava Cache的缓存统计

guava cache很适合做进程内的缓存,本文先学习下它的缓存统计功能,需要使用recordStats()打开缓存统计功能。有一点需要注意下:可以通过修改底层map给缓存添加数据,也可以获取数据。通...

Guava Cache使用笔记

我刚开始使用时还以为Guava Cache跟HashMap一样,get(null)返回null。  实际上Guava整体设计思想就是拒绝null的,很多地方都会执行com.google.common....

Guava Cache特性:对于同一个key,只让一个请求回源load数据,其他线程阻塞等待结果

使用Guava确实可以做到:对于同一个key,无论有多少请求,都只会允许一个线程去加载数据。但是也有一个很致命的缺陷:上面8个线程中,有一个线程实际去加载数据,其余7个线程都被阻塞了。如果能做到,当一...

Guava Cache使用

缓存,在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说,cache 就是为了提升系统性能而开辟的一块内存空间。   缓存的主要作用是暂时在内存中保存业务系统的数据处理结果,并且等待下...

缓存框架Guava Cache部分源码分析

在本地缓存中,最常用的就是OSCache和谷歌的Guava Cache。其中OSCache在07年就停止维护了,但它仍然被广泛的使用。谷歌的Guava Cache也是一个非常优秀的本地缓存,使用起来非...
  • zjccsg
  • zjccsg
  • 2016年07月17日 14:33
  • 998

Guava Cache 数据变化实现回调的监听器RemovalListener

上一篇介绍了guava的使用,实现了项目第一个需求定期清理cache数据,第二个需求,我们需要在缓存被移除的时候,得到通知产生回调,并做一些额外处理工作。这个时候RemovalListener就派上用...

深入Guava Cache的refresh和expire刷新机制

Guava Cache是本地缓存的不二之选,用起来真不错呵,可是你真的知道怎么使用才能满足需求?今天我们深入探讨一下Expire和Refresh。...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Google Guava之--cache
举报原因:
原因补充:

(最多只允许输入30个字)