Ehcache初体验(ehcache-server restful web services)

  本篇文章为你整理了Ehcache初体验(ehcache-server restful web services)的详细内容,包含有ehcache使用详细教程 ehcache-server restful web services ehcache3 ehcache官网 Ehcache初体验,希望能帮助你了解 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 的全名是 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

  以上就是Ehcache初体验(ehcache-server restful web services)的详细内容,想要了解更多 Ehcache初体验的内容,请持续关注盛行IT软件开发工作室。

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: