guava缓存_常用的缓存技术

A. 为什么要用 redis 而不用 map/guava 做缓存

因为前置款存的话要好一点，而且实用性要高一点。

B. guava cache中怎么清除缓存

【手动清理】
1、进入手机设置选项，选择设置——应用。
2、按一下Menu键，选择“按大小排序”。
3、在排序好的列表中点击应用程序。
4、点击"清除缓存"选项，即刻就会释放缓存

C. 如何使用Guava的缓存管理

D. Google guava和Apache commons哪个好

Guava 的 FAQ 部分有专门解答：

Why did Google build all this, when it could have tried to improve the Apache Commons Collections instead?
The Apache Commons Collections very clearly did not meet our needs. It does not use generics, which is a problem for us as we hate to get compilation warnings from our code. It has also been in a "holding pattern" for a long time. We could see that it would require a pretty major investment from us to fix it up until we were happy to use it, and in the meantime, our own library was already growing organically.
An important difference between the Apache library and ours is that our collections very faithfully adhere to the contracts specified by the JDK interfaces they implement. If you review the Apache documentation, you'll find countless examples of violations. They deserve credit for pointing these out so clearly, but still, deviating from standard collection behavior is risky! You must be careful what you do with such a collection; bugs are always just waiting to happen.
Our collections are fully generified and never violate their contracts (with isolated exceptions, where JDK implementations have set a strong precedent for acceptable violations). This means you can pass one of our collections to any method that expects a Collection and feel pretty confident that things will work exactly as they should.

简单地说：
Apache Commons Collections 3.x 不支持泛型，Guava 支持
Guava 实现了 JDK 的标准接口，而 Apache Commons Collections 3.x 有很多违反标准的地方

Apache Commons Collections 4.x 的发行注记如下：

Majorchangessince3.2.1
(varargs,Iterable)
Removeddeprecatedclasses/
.util.Queue
/Get(seealsopackagesplitmap)

从 4.x 开始，Apache Commons Collections 开始使用 JDK 5 的特性（包括泛型），此外也去除、添加了很多内容

各有千秋, 我主要使用Apache Commons ,辅助使用 Google guava

但是细节方法上还是有区别的, 比如

GoogleGuava Splitter 对比 Apache StringUtils

apache commons的StringUtils提供的常用功能介绍，但是google的guava也提供了一些字符串处理的常见功能，所以，将对两者的字符串分割函数做一次比较详细的对比（结果比较surprise）。

区别
首先看基本的使用方法：

//ApacheStringUtils...
String[]tokens1=StringUtils.split("one,two,three",',');

//GoogleGuavasplitter...
Iteratable<String>tokens2=Splitter.on(','),split("one,two,three");

google提供的方法更加的面向对象一点，因为它要先创建一个Splitter对象，然后使用它来分割字符串，而apache的方法则有点函数式编程的味道，它的方法都是静态的。

这里我更加倾向于采用google的splitter，因为这个对象是可以重用的，且可以在其上附加更多的功能，比如trim，去掉空的元素等，一切都很简单。

SplitterniceCommaSplitter=Splitter.on(',').omitEmptyString().trimResults();
niceCommaSplitter.split("one,,two,three");//"one","two","three"
niceCommaSplitter.split("four,five");//"four","five"

看起来有点用，还有其他区别么？
另外一个需要注意的地方就是Splitter返回的是Iteratable<String>，而StringUtils.split返回的是一个String数组。

大部分使用分隔符的情况是我们需要对字符串按照分隔符进行遍历处理，仅此而已。
下面就是常用的代码性能对比的例子：

finalStringnumberList="One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten";

longstart=System.currentTimeMillis();
for(inti=0;i<1000000;i++){
StringUtils.split(numberList,',');
}
System.out.println(System.currentTimeMillis()-start);

start=System.currentTimeMillis();
for(inti=0;i<1000000;i++){
Splitter.on(',').split(numberList);
}
System.out.println(System.currentTimeMillis()-start);

代码很简单，就是都对同一个字符串进行100万次的分隔操作，看看时间上的区别，结果如下：

983
165

很明显，guava的速度快很多，这个程序如果运行在每天处理大量字符串的服务中，那么性能差异更加明显。我想其中的原因是Splitter返回的是Iterable<String>，而StringUtils.split返回的是一个String[]，需要创建新的String对象，导致耗时增加。

如果我们对Splitter对象缓存，那么速度提高更多：

start=System.currentTimeMillis();
Splitters=Splitter.on(',');
for(inti=0;i<1000000;i++){
s.split(numberList);
}
System.out.println(System.currentTimeMillis()-start);

结果为12，神奇吧，呵呵

E. 常用的缓存技术

第一章常用的缓存技术
1、常见的两种缓存

本地缓存：不需要序列化，速度快，缓存的数量与大小受限于本机内存
分布式缓存：需要序列化，速度相较于本地缓存较慢，但是理论上缓存的数量与大小无限（因为缓存机器可以不断扩展）
2、本地缓存

Google guava cache：当下最好用的本地缓存
Ehcache：spring默认集成的一个缓存，以spring cache的底层缓存实现类形式去操作缓存的话，非常方便，但是欠缺灵活，如果想要灵活使用，还是要单独使用Ehcache
Oscache：最经典简单的页面缓存
3、分布式缓存

memcached：分布式缓存的标配
Redis：新一代的分布式缓存，有替代memcached的趋势
3.1、memcached

经典的一致性hash算法
基于slab的内存模型有效防止内存碎片的产生（但同时也需要估计好启动参数，否则会浪费很多的内存）
集群中机器之间互不通信（相较于Jboss cache等集群中机器之间的相互通信的缓存，速度更快<--因为少了同步更新缓存的开销，且更适合于大型分布式系统中使用）
使用方便（这一点是相较于Redis在构建客户端的时候而言的，尽管redis的使用也不困难）
很专一（专做缓存，这一点也是相较于Redis而言的）
3.2、Redis

可以存储复杂的数据结构（5种）
strings-->即简单的key-value，就是memcached可以存储的唯一的一种形式，接下来的四种是memcached不能直接存储的四种格式（当然理论上可以先将下面的一些数据结构中的东西封装成对象，然后存入memcached，但是不推荐将大对象存入memcached，因为memcached的单一value的最大存储为1M，可能即使采用了压缩算法也不够，即使够，可能存取的效率也不高，而redis的value最大为1G）
hashs-->看做hashTable
lists-->看做LinkedList
sets-->看做hashSet，事实上底层是一个hashTable
sorted sets-->底层是一个skipList
有两种方式可以对缓存数据进行持久化
RDB
AOF
事件调度
发布订阅等
4、集成缓存

专指spring cache，spring cache自己继承了ehcache作为了缓存的实现类，我们也可以使用guava cache、memcached、redis自己来实现spring cache的底层。当然，spring cache可以根据实现类来将缓存存在本地还是存在远程机器上。

5、页面缓存

在使用jsp的时候，我们会将一些复杂的页面使用Oscache进行页面缓存，使用非常简单，就是几个标签的事儿；但是，现在一般的企业，前台都会使用velocity、freemaker这两种模板引擎，本身速度就已经很快了，页面缓存使用的也就很少了。

总结：

在实际生产中，我们通常会使用guava cache做本地缓存+redis做分布式缓存+spring cache就集成缓存（底层使用redis来实现）的形式
guava cache使用在更快的获取缓存数据，同时缓存的数据量并不大的情况
spring cache集成缓存是为了简单便捷的去使用缓存（以注解的方式即可），使用redis做其实现类是为了可以存更多的数据在机器上
redis缓存单独使用是为了弥补spring cache集成缓存的不灵活
就我个人而言，如果需要使用分布式缓存，那么首先redis是必选的，因为在实际开发中，我们会缓存各种各样的数据类型，在使用了redis的同时，memcached就完全可以舍弃了，但是现在还有很多公司在同时使用memcached和redis两种缓存。

F. 如何使用Guava的缓存管理

首先，看一下使用范例：

Java代码
LoadingCache<Key,Graph> graphs =CacheBuilder.newBuilder()
.maximumSize(1000)
.expireAfterWrite(10,TimeUnit.MINUTES)
.removalListener(MY_LISTENER)
.build(
newCacheLoader<Key,Graph>(){
publicGraph load(Key key)throwsAnyException{
return createExpensiveGraph(key);
}
});

适用性
缓存在很多情况下都是非常有用的。比如，我们需要多次根据给定的输入获取值，而且该值计算或者获取的开销是非常昂贵的。
缓存和ConcurrentMap是非常相像的，但是它们也不完全一样。最根本的区别就是，ConcurrentMap会持有所有添加的对象，直到被显示的移除。而缓存为了限制其内存的使用，通常都会配置成可以自动的将对象移除。在某些情况下即使不自动移除对象也是非常有用的，如LoadingCache它会自动加载缓存对象。
一般，Guava缓存适用于以下几种情况：
你愿意花费一些内存来换取性能提升；
你预测到某些键会多次进行查询；
你的缓存数据不超过内存（Guava缓存是单个应用中的本地缓存。它不会将数据存储到文件中，或者外部服务器。如果不适合你，可以考虑一下 Memcached）。
如果你的需要符合上面所说的每一条，那么选择Guava缓存绝对没错。
使用CacheBuilder的构建模式可以获取一个Cache，如上面的范例所示。但是如何进行定制才是比较有趣的。
注意：如果你不需要缓存的这些特性，那么使用ConcurrentHashMap会有更好的内存效率，但是如果想基于旧有的ConcurrentMap复制实现Cache的一些特性，那么可能是非常困难或者根本不可能。
加载
对于缓存首先需要明确的是：有没有一个方法可以通过给定的键来计算/加载相应的值？如果有，那么可以使用CacheLoader。如果没有这样的方法，或者你想复写缓存的加载方式，但你仍想保留“get-if-absent-compute”语义，你可以在调用get方法时传入一个Callable实例，来达到目的。缓存的对象可以通过Cache.put直接插入，但是自动加载是首选，因为自动加载可以更加容易的判断所有缓存信息的一致性。
From a CacheLoader
LoadingCache 缓存是通过一个CacheLoader来构建缓存。创建一个CacheLoader仅需要实现V load(K key) throws Exception方法即可。下面的范例就是如何创建一个LoadingCache：
Java代码
LoadingCache<Key,Graph> graphs =CacheBuilder.newBuilder()
.maximumSize(1000)
.build(
newCacheLoader<Key,Graph>(){
publicGraph load(Key key)throwsAnyException{
return createExpensiveGraph(key);
}
});

...
try{
return graphs.get(key);
}catch(ExecutionException e){
thrownewOtherException(e.getCause());
}
通过方法get(K)可以对LoadingCache进行查询。该方法要不返回已缓存的值，要不通过CacheLoader来自动加载相应的值到缓存中。这里需要注意的是：CacheLoader可能会抛出Exception，LoaderCache.get(K)则可能会抛出ExecutionException。假如你定义的CacheLoader没有声明检查型异常，那么可以通过调用getUnchecked(K)来获取缓存值；但是一旦当CacheLoader中声明了检查型异常，则不可以调用getUnchecked。
Java代码
LoadingCache<Key,Graph> graphs =CacheBuilder.newBuilder()
.expireAfterAccess(10,TimeUnit.MINUTES)
.build(
newCacheLoader<Key,Graph>(){
publicGraph load(Key key){// no checked exception
return createExpensiveGraph(key);
}
});

...
return graphs.getUnchecked(key);
批量查询可以使用getAll(Iterable<? extends K>)方法。缺省，getAll方法将循环每一个键调用CacheLoader.load方法获取缓存值。当缓存对象的批量获取比单独获取更有效时，可以通过复写CacheLoader.loadAll方法实现缓存对象的加载。此时当调用getAll(Iterable)方法时性能也会提升。
需要注意的是CacheLoader.loadAll的实现可以为没有明确要求的键加载缓存值。比如，当为某组中的一些键进行计算时，loadAll方法则可能会同时加载组中其余键的值。
From a Callable
所有Guava缓存，不论是否会自动加载，都支持get(K, Callable(V))方法。当给定键的缓存值已存在时则直接返回，否则通过指定的Callable方法进行计算并将值存放到缓存中。直到加载完成时，相应的缓存才会被更改。该方法简单实现了"if cached, return; otherwise create, cache and return"语义。
Java代码
Cache<Key,Value> cache =CacheBuilder.newBuilder()
.maximumSize(1000)
.build();// look Ma, no CacheLoader
...
try{
// If the key wasn't in the "easy to compute" group, we need to
// do things the hard way.
cache.get(key,newCallable<Value>(){
@Override
publicValue call()throwsAnyException{
return doThingsTheHardWay(key);
}
});
}catch(ExecutionException e){
thrownewOtherException(e.getCause());
}

直接插入
使用cache.put(key, value)方法可以将值直接插入到缓存中，但这将会覆盖缓存中已存在的值。通过使用Cache.asMap()所导出的ConcurrentMap对象中的方法也可以对缓存进行修改。但是，请注意asMap中的任何方法都不能自动的将数据加载到缓存中。也就是说，asMap中的各方法是在缓存自动加载范围之外来运作。所以，当你使用CacheLoader或Callable来加载缓存时，应该优先使用Cache.get(K, Callable<V>)，而不是Cache.asMap().putIfAbsent。
缓存回收
残酷的现实是我们可以肯定的说我们没有足够的内存来缓存一切。你必须来决定：什么时候缓存值不再值得保留？Guava提供了三种基本的缓存回收策略：基于容量回收策略，基于时间回收策略，基于引用回收策略。
基于容量回收策略
使用CacheBuilder.maximumSize(long)可以设置缓存的最大容量。缓存将会尝试回收最近没有使用，或者没有经常使用的缓存项。警告：缓存可能会在容量达到限制之前执行回收，通常是在缓存大小逼近限制大小时。
另外，如果不同的缓存项有不同的“权重”，如，缓存项有不同的内存占用，此时你需要使用CacheBuilder.weigher(Weigher)指定一个权重计算函数，并使用CacheBuilder.maxmumWeight(long)设定总权重。和maximumSize同样需要注意的是缓存也是在逼近总权重的时候进行回收处理。此外，缓存项的权重是在创建时进行计算，此后不再改变。
Java代码
LoadingCache<Key,Graph> graphs =CacheBuilder.newBuilder()
.maximumWeight(100000)
.weigher(
newWeigher<Key,Graph>(){
publicint weigh(Key k,Graph g){
return g.vertices().size();
}
})
.build(
newCacheLoader<Key,Graph>(){
publicGraph load(Key key){// no checked exception
return createExpensiveGraph(key);
}
});

基于时间回收策略
CacheBuilder为基于时间的回收提供了两种方式：
expireAfterAccess(long, TimeUnit) 当缓存项在指定的时间段内没有被读或写就会被回收。这种回收策略类似于基于容量回收策略；
expireAfterWrite(long, TimeUnit) 当缓存项在指定的时间段内没有更新就会被回收。如果我们认为缓存数据在一段时间后数据不再可用，那么可以使用该种策略。
就如下面的讨论，定时过期回收会在写的过程中周期执行，偶尔也会读的过程中执行。
测试定时回收
测试定时回收其实不需要那么痛苦的，我们不必非得花费2秒来测试一个2秒的过期。在构建缓存时使用Ticker接口，并通过CacheBuilder.ticker(Ticker)方法指定时间源，这样我们就不用傻乎乎等系统时钟慢慢的走了。
基于引用回收策略
通过键或缓存值的弱引用(weak references)，或者缓存值的软引用(soft references)，Guava可以将缓存设置为允许垃圾回收。
CacheBuilder.weakKeys() 使用弱引用存储键。当没有(强或软)引用到该键时，相应的缓存项将可以被垃圾回收。由于垃圾回收是依赖==进行判断，因此这样会导致整个缓存也会使用==来比较键的相等性，而不是使用equals()；
CacheBuilder.weakValues() 使用弱引用存储缓存值。当没有(强或软)引用到该缓存项时，将可以被垃圾回收。由于垃圾回收是依赖==进行判断，因此这样会导致整个缓存也会使用==来比较缓存值的相等性，而不是使用equals()；
CacheBuilder.softValues() 使用软引用存储缓存值。当响应需要时，软引用才会被垃圾回收通过最少使用原则回收掉。由于使用软引用造成性能上的影响，我们强烈建议使用可被预言的maximum cache size的策略来代替。同样使用softValues()缓存值的比较也是使用==，而不是equals()。
显示移除
在任何时候，你都可以可以通过下面的方法显式将无效的缓存移除，而不是被动等待被回收：
使用Cache.invalidate(key)单个移除;
使用Cache.invalidteAll(keys)批量移除；
使用Cache.invalidateAll()移除全部。

G. guava的LoadingCache的默认大小和生命周期是多少

当Session对象为空，Session对象的生命周期还没有开始，Session ID Manager会为每一个请求页面赋予一个新的session ID，且每一次请求都不相同，直到有数据存储在Session对象中时，就按照图2所示的过程进行会话状态维护。有两个事件与Session对象的生命周期密切相关，分别是Session_OnStart（会话开始）和Session_OnEnd（会话结束）。如果为Session_OnStart事件定义了处理程序（event handler），那么Session的生命周期从第一次请求该页面就开始，该页面的Session ID一被赋予就不再改变，Session即使为空也会被存储，因此，从性能的角度考虑，只有在必要时才为Session_OnStart事件定义事件处理程序。Session_OnEnd事件只有在InProc模式下，且Session已经存在的前提下才能被触发，这是因为该事件是由Cache对象在删除失效的Session对象时触发，可在该事件的处理程序中通过编码终止Session对象。
最后，再补充一点。由上面的讨论可知，Session 对象的实现与Cache对象有着密切联系，尤其是再InProc模式下，但是Session不能提供和Cache那样丰富的缓存过期和依赖机制。在InProc模式下，Session对象中的数据是否失效，只能通过设定sliding time来控制，即在指定的时间间隔内没用使用Session中的数据，数据自动删除。

H. 如何使用Guava的缓存管理

对于缓存首先需要明确的是：有没有一个方法可以通过给定的键来计算/加载相应的值？如果有，那么可以使用CacheLoader。如果没有这样的方法，或者你想复写缓存的加载方式，但你仍想保留“get-if-absent-compute”语义，你可以在调用get方法时传入一个Callable实例，来达到目的。缓存的对象可以通过Cache.put直接插入，但是自动加载是首选，因为自动加载可以更加容易的判断所有缓存信息的一致性。

I. 关闭内存缓存对效能有影响吗

没有。

在系统中所有的进程之间是共享CPU和主存这些内存资源的。当进程数量变多时，所需要的内存资源就会相应的增加。可能会导致部分程序没有主存空间可用。此外，由于资源是共享的，那么就有可能导致某个进程不小心写了另一个进程所使用的内存，进而导致程序运行不符合正常逻辑。

内存缓存注意事项

使用Java堆内存来存储对象。使用堆缓存的好处是没有序列化/反序列化，是最快的缓存。缺点也很明显，当缓存的数据量很大时，GC（垃圾回收）暂停时间会变长，存储容量受限于堆空间大小。一般通过软引用/弱引用来存储缓存对象。

即当堆内存不足时，可以强制回收这部分内存释放堆内存空间。一般使用堆缓存存储较热的数据。可以使用Guava Cache、Ehcache 3.x、 MapDB实现。

J. JAVA目前比较常用的缓存有哪些集中式缓存与分布式缓存有何区别它们应用场景是

java目前常用的缓存：
Generic
JCache (JSR-107) (EhCache 3, Hazelcast, Infinispan, etc)
EhCache 2.x
Hazelcast
Infinispan
Couchbase
Redis
Caffeine
Guava (deprecated)
Simple
建议使用spring boot集成方式，可插拔，简单。
集中式缓存适用场景：
1、服务器集群部署。
2、数据高一致性（任何数据变化都能及时的被查询到）

分布式缓存适用场景：
系统需要缓存的数据量大
对数据的可用性较高的情况

需要横向扩展，从而达到缓存的容量无限的要求

guava缓存

与guava缓存相关的内容