Ehcache初体验
前言
读张开涛写的《亿级流量网站架构核心技术》里面讲到使用Java缓存：堆内缓存，堆外缓存，磁盘缓存，分布式缓存。介绍了几种缓存工具：Gauva Cache, Ehcache和MapDB。 其中Gauva Cache是google开发的，它只提供了堆内缓存。 Ehcache支持的比较全面，基本都支持了。之前我没有使用过这些缓存工具，书读一遍也没有什么印象，自己动手写一下能体会更深。这篇博客就是基本的使用，然后加上JMH来对比一下他们的性能。JMH也是第一次使用，其中也花了些时间，以后需要做性能对比的时候它能帮上忙。
Ehcache使用
要使用Ehcache首先要引入POM文件
<dependency>
<groupId>org.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>3.10.0</version>
</dependency>
接着是如何使用，比较简单，直接看代码
CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build(true);
CacheConfiguration<Long, String> heapCacheConfig = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
ResourcePoolsBuilder.heap(100)).build();
Cache<Long, String> heapCache = cacheManager.createCache("heapCache", heapCacheConfig);
heapCache.put(1L,"hello world");
heapCache.get(lL);
第一行定义cacheManager
接着定义一个cacheconfig, 在这个config里面就指定了key和value的类型和存储在哪里
ResourcePoolsBuilder.heap(100) 意思就是在堆内存100条，当超过100后，会触发剔除，会剔除一些数据，这也是和我们通常在Java程序中直接用Map的区别，Map中的数据不会自动剔除。
第三行就是使用cacheManager和config创建出Cache对象，后面我们就直接使用它来存取数据
第四行就是存数据
第五行就是取数据
整体上非常简单，更多比如过期策略，缓存空间这些用的时候再细看，可以参考官方文档https://www.ehcache.org/
这里给出三个不同的存储类型代码， 后面我们就对比三种类型的性能差异
import org.ehcache.Cache;
import org.ehcache.CacheManager;
import org.ehcache.config.CacheConfiguration;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.units.MemoryUnit;
public class EhCacheService {
private Cache<Long, String> heapCache;
private Cache<Long, String> offHeapCache;
private Cache<Long, String> multipleTierCache;
public EhCacheService()
{
CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build(true);
CacheConfiguration<Long, String> heapCacheConfig = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
ResourcePoolsBuilder.heap(100)).build();
CacheConfiguration<Long, String> offheapCacheConfig = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
ResourcePoolsBuilder.newResourcePoolsBuilder().offheap(10, MemoryUnit.MB)).build();
CacheConfiguration<Long, String> multipleCacheConfig = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
ResourcePoolsBuilder.heap(100).offheap(10, MemoryUnit.MB)).build();
heapCache = cacheManager.createCache("heapCache", heapCacheConfig);
offHeapCache = cacheManager.createCache("offHeapCache", offheapCacheConfig);
multipleTierCache = cacheManager.createCache("multipleTierCache", multipleCacheConfig);
}
public void addHeapCache(Long l, String v)
{
heapCache.put(l,v);
}
public String getHeapCache(Long l)
{
return heapCache.get(l);
}
public void addOffHeapCache(Long l, String v)
{
offHeapCache.put(l,v);
}
public String getOffHeapCache(Long l)
{
return offHeapCache.get(l);
}
public void addMultipleTierCache(Long l, String v)
{
multipleTierCache.put(l,v);
}
public String getMultipleTierCache(Long l)
{
return multipleTierCache.get(l);
}
}
heapCache 是堆缓存
offHeapCache 是堆外缓存
multipleTierCache 是多层缓存，首先是堆内，如果堆内没有，就去堆外找。
JMH
JMH 的全名是 Java Microbenchmark Harness， 用它可以方便的对比出代码的性能
首先引入Pom文件
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>1.28</version>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
<version>1.28</version>
</dependency>
这里直接给出对比代码
package ken.ehcache.demo;
import java.util.concurrent.TimeUnit;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Thread)
@Fork(1)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Warmup(iterations = 3)
@Measurement(iterations = 5)
public class JmhEhCacheService {
private EhCacheService ehCacheService = new EhCacheService();
private Cache<Long,String> guavaCache = CacheBuilder.newBuilder()
.concurrencyLevel(4)
.expireAfterWrite(10, TimeUnit.MINUTES)
.maximumSize(100)
.build();
@Benchmark
public void addGuava() {
for (Long i = 0L; i < 100; i++) {
guavaCache.put(i, "HelloWorld" + i);
}
}
@Benchmark
public void addHeap() {
for (Long i = 0L; i < 100; i++) {
ehCacheService.addHeapCache(i, "HelloWorld" + i);
}
}
@Benchmark
public void addOffHeap() {
for (Long i = 0L; i < 100; i++) {
ehCacheService.addOffHeapCache(i, "HelloWorld" + i);
}
}
@Benchmark
public void addMultipleTierCache() {
for (Long i = 0L; i < 100; i++) {
ehCacheService.addMultipleTierCache(i, "HelloWorld" + i);
}
}
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(JmhEhCacheService.class.getSimpleName())
.build();
new Runner(opt).run();
}
}
Benchmark 注解就是把他们几个方法再一起对比，这里我同样加入了Guava Cache来进入对比
方法就是往各种cache加入100条数据，对比他们的性能。
这是性能的结果
Benchmark Mode Cnt Score Error Units
JmhEhCacheService.addGuava avgt 5 0.016 ± 0.001 ms/op
JmhEhCacheService.addHeap avgt 5 0.010 ± 0.001 ms/op
JmhEhCacheService.addMultipleTierCache avgt 5 0.172 ± 0.002 ms/op
JmhEhCacheService.addOffHeap avgt 5 0.172 ± 0.006 ms/op
通过这个结果我们可以看到堆内缓存比堆外缓存快很多， Guava也是堆内缓存。
同样我也做了一下读的对比，这里不贴代码了
JmhEhCacheServiceRead.getGuavaCache avgt 5 0.006 ± 0.001 ms/op
JmhEhCacheServiceRead.getHeap avgt 5 0.002 ± 0.001 ms/op
JmhEhCacheServiceRead.getMultipleTierCache avgt 5 0.003 ± 0.001 ms/op
JmhEhCacheServiceRead.getOffHeap avgt 5 0.060 ± 0.002 ms/op
堆内缓存同样比堆外要快，多层的缓存因为数据都在堆内，所以它和堆内也很接近。
总结
缓存是个解决高并发非常有用的工具，基本上出现性能问题，就需要引入缓存。 今天学习的这两个工具都只是本地缓存，如果数据量比较大以后，就需要引入分布式缓存。还有就是缓存比较难的是如何做数据同步，保证缓存中的数据是新的， 不然就会有问题。 读书的时候，读一遍，往往理解得不深，动手写一写，找些资料加强一下，是个不错的提升方式。这些资料如下
https://www.wdbyte.com/2020/08/develop/tool-jmh/#java-性能测试难题
https://mkyong.com/java/java-jmh-benchmark-tutorial/
https://www.jianshu.com/p/17e72bb01bf1