Ehcache初體驗_ZenDei技術網路在線

靜態類和非靜態類靜態類只能是內部類，外部類不能用static修飾，內部類可以使用static修飾。創建方式：外部類.靜態內部類對象名=外部類.new 靜態內部類（）; 外部類對象名= new 外部類(); 外部類.非靜態內部類對象名1 = 對象名.new 非靜態內部類()；抽象類是否可 ...

前言

讀張開濤寫的《億級流量網站架構核心技術》裡面講到使用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