使用Guava Cache原理及最佳实践

"automatic loading of entries into the cache"

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>29.0-jre</version>
</dependency>

private static List<String> rpcCall(String cityId) {
    // 模仿从数据库中取数据
    try {
        switch (cityId) {
            case "0101":
	            System.out.println("load cityId:" + cityId);
                return ImmutableList.of("上海", "北京", "广州", "深圳");
        }
    } catch (Exception e) {
        // 记日志
    }
    return Collections.EMPTY_LIST;
}

//创建一个LoadingCache，并可以进行一些简单的缓存配置
private static LoadingCache<String, Optional<List<String>> > loadingCache = CacheBuilder.newBuilder()
    //配置最大容量为100，基于容量进行回收
    .maximumSize(100)
    //配置写入后多久使缓存过期-下文会讲述
    .expireAfterWrite(3, TimeUnit.SECONDS)
    //配置写入后多久刷新缓存-下文会讲述
    .refreshAfterWrite(3, TimeUnit.SECONDS)
    //key使用弱引用-WeakReference
    .weakKeys()
    //当Entry被移除时的监听器-下文会讲述
    .removalListener(notification -> System.out.println("notification=" + notification))
    //创建一个CacheLoader，重写load方法，以实现"当get时缓存不存在，则load，放到缓存并返回的效果
    .build(new CacheLoader<String, Optional<List<String>>>() {
        //重点，自动写缓存数据的方法，必须要实现
        @Override
        public Optional<List<String>> load(String cityId) throws Exception {
            return Optional.ofNullable(rpcCall(cityId));
        }
        //异步刷新缓存-下文会讲述
        @Override
        public ListenableFuture<Optional<List<String>>> reload(String cityId, Optional<List<String>> oldValue) throws Exception {
            return super.reload(cityId, oldValue);
        }
    });

// 测试
public static void main(String[] args) {

    try {
        System.out.println("load from cache once : " + loadingCache.get("0101").orElse(Lists.newArrayList()));
        Thread.sleep(4000);
        System.out.println("load from cache two : " + loadingCache.get("0101").orElse(Lists.newArrayList()));
        Thread.sleep(2000);
        System.out.println("load from cache three : " + loadingCache.get("0101").orElse(Lists.newArrayList()));
        Thread.sleep(2000);
        System.out.println("load not exist key from cache : " + loadingCache.get("0103").orElse(Lists.newArrayList()));

    } catch (ExecutionException | InterruptedException e) {
        //记录日志
    }
}

//创建一个callableCache，并可以进行一些简单的缓存配置
private static Cache<String, Optional<List<String>>> callableCache = CacheBuilder.newBuilder()
    //最大容量为100（基于容量进行回收）
    .maximumSize(100)
    //配置写入后多久使缓存过期-下文会讲述
    .expireAfterWrite(3, TimeUnit.SECONDS)
    //key使用弱引用-WeakReference
    .weakKeys()
    //当Entry被移除时的监听器
    .removalListener(notification -> System.out.println("notification=" + notification))
    //不指定CacheLoader
    .build();

// 测试
public static void main(String[] args) {
    try {
        System.out.println("load from callableCache once : " + callableCache.get("0101", () -> Optional.ofNullable(rpcCall("0101"))).orElse(Lists.newArrayList()));
        Thread.sleep(4000);
        System.out.println("load from callableCache two : " + callableCache.get("0101", () -> Optional.ofNullable(rpcCall("0101"))).orElse(Lists.newArrayList()));
        Thread.sleep(2000);
        System.out.println("load from callableCache three : " + callableCache.get("0101", () -> Optional.ofNullable(rpcCall("0101"))).orElse(Lists.newArrayList()));
        Thread.sleep(2000);
        System.out.println("load not exist key from callableCache : " + callableCache.get("0103", () -> Optional.ofNullable(rpcCall("0103"))).orElse(Lists.newArrayList()));
    } catch (ExecutionException | InterruptedException e) {
        //记录日志
    }
}

// 声明一个CallableCache，不需要CacheLoader
private static  Cache<String, Optional<List<String>>> localCache = CacheBuilder
    .newBuilder()
    .maximumSize(100)
    .expireAfterAccess(10, TimeUnit.MINUTES)
    .removalListener(notification -> System.out.println("notification=" + notification))
    .build();


// 测试。使用时自主控制get、put等操作
public static void main(String[] args) {
    try {
        String cityId = "0101";

        Optional<List<String>> ifPresent1 = localCache.getIfPresent(cityId);
        System.out.println("load from localCache one : " + ifPresent1);
        // 做判空，不存在时手工获取并put数据到localCache中
        if (ifPresent1 == null || ifPresent1.isPresent() || CollectionUtils.isEmpty(ifPresent1.get())) {
            List<String> stringList = rpcCall(cityId);
            if (CollectionUtils.isNotEmpty(stringList)) {
                localCache.put(cityId, Optional.ofNullable(stringList));
            }
        }
        Optional<List<String>> ifPresent2 = localCache.getIfPresent(cityId);
        System.out.println("load from localCache two : " + ifPresent2);

        // 失效某个key，或者loadingCache.invalidateAll() 方法
        localCache.invalidate(cityId);
        Optional<List<String>> ifPresent3 = localCache.getIfPresent(cityId);
        System.out.println("load from localCache three : " + ifPresent3);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
	// 缓存最多可以存储1000个条目
    .maximumSize(1000) 
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
	// 缓存最多可以存储的总权重
    .maximumWeight(10000) 
    .weigher(new Weigher<KeyType, ValueType>() {
        public int weigh(KeyType key, ValueType value) {
            // 定义如何计算每个条目的权重
            return getSizeInBytes(key, value);
        }
    })
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .expireAfterWrite(30, TimeUnit.MINUTES)
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .expireAfterAccess(15, TimeUnit.MINUTES)
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .weakKeys()
    .build();

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .softValues()
    .build();

cache.invalidate(key);

cache.invalidateAll(keys);

cache.invalidateAll();

// 移除单个条目
cache.asMap().remove(key);

// 批量移除条目
for (KeyType key : keys) {
    cache.asMap().remove(key);
}

// 移除满足特定条件的条目
cache.asMap().entrySet().removeIf(entry -> entry.getValue().equals(someValue));

Cache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
    .removalListener(new RemovalListener<KeyType, ValueType>() {
        @Override
        public void onRemoval(RemovalNotification<KeyType, ValueType> notification) {
            // 处理移除事件
        }
    })
    .build();

@Override
// 1、执行LocalLoadingCache中的get方法
public V get(K key) throws ExecutionException {
  return localCache.getOrLoad(key);
}

// 2、执行get 或 load方法
V getOrLoad(K key) throws ExecutionException {
  return get(key, defaultLoader);
}

// 3、核心get方法  
V get(K key, CacheLoader<? super K, V> loader) throws ExecutionException {
  int hash = hash(checkNotNull(key));
  // segmentFor方法根据hash的高位从segments数组中取出相应的segment实例，执行segment实例的get方法
  return segmentFor(hash).get(key, hash, loader);
}

// 4、Segment中的get方法
V get(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
    checkNotNull(key);
    checkNotNull(loader);
    try {
    	// 当前Segment中存活的条目个数不为0
        if (count != 0) { // read-volatile
            // don't call getLiveEntry, which would ignore loading values
            // getEntry会校验key，所以key为弱引用被回收的场景，取到的e是null。稍后展开介绍该方法
            LocalCache.ReferenceEntry<K, V> e = getEntry(key, hash);
            if (e != null) {
                long now = map.ticker.read();
                // 此处有个getLiveValue(),这个方法是拿到当前存活有效的缓存值，稍后展开介绍该方法
                V value = getLiveValue(e, now);
                if (value != null) {
                	// 记录该缓存被访问了。此时expireAfterAccess相关的时间会被刷新
                    recordRead(e, now);
                    // 记录缓存击中
                    statsCounter.recordHits(1);
                    // 用来判断是直接返回现有value，还是等待刷新
                    return scheduleRefresh(e, key, hash, value, now, loader);
                }
                LocalCache.ValueReference<K, V> valueReference = e.getValueReference();
                // 只有key存在，但是value不存在（被回收）、或缓存超时的情况会到达这里
	            // 如果已经有线程在加载缓存了，后面的线程不会重复加载，而是等待加载的结果
                if (valueReference.isLoading()) {
                    return waitForLoadingValue(e, key, valueReference);
                }
            }
        }

        // at this point e is either null or expired;
        // 如果不存在或者过期，就通过loader方法进行加载（该方法会对当前整个Segment加锁，直到从数据源加载数据，更新缓存）;
        // 走到这里的场景：
        // 1）segment为空
        // 2）key或value不存在（没有缓存，或者弱引用、软引用被回收），
        // 3）缓存超时（expireAfterAccess或expireAfterWrite触发的）
        return lockedGetOrLoad(key, hash, loader);
    } catch (ExecutionException ee) {
        Throwable cause = ee.getCause();
        if (cause instanceof Error) {
            throw new ExecutionError((Error) cause);
        } else if (cause instanceof RuntimeException) {
            throw new UncheckedExecutionException(cause);
        }
        throw ee;
    } finally {
        postReadCleanup();
    }
}

    @Nullable
    ReferenceEntry<K, V> getEntry(Object key, int hash) {
      // getFirst用来根据hash获取table中相应位置的链表的头元素
      for (ReferenceEntry<K, V> e = getFirst(hash); e != null; e = e.getNext()) {
        // hash不相等的，key肯定不相等。hash判等是int判等，比直接用key判等要快得多
        if (e.getHash() != hash) {
          continue;
        }
 
        K entryKey = e.getKey();
        // entryKey == null的情况，是key为软引用或者弱引用，已经被GC回收了。直接清理掉
        if (entryKey == null) {
        // 
          tryDrainReferenceQueues();
          continue;
        }
 
        if (map.keyEquivalence.equivalent(key, entryKey)) {
          return e;
        }
      }
 
      return null;
    }

V getLiveValue(LocalCache.ReferenceEntry<K, V> entry, long now) {
	// 软引用或者弱引用的key被清理掉了
    if (entry.getKey() == null) {
    	// 清理非强引用的队列
        tryDrainReferenceQueues();
        return null;
    }
    V value = entry.getValueReference().get();
    // 软引用的value被清理掉了
    if (value == null) {
    	// 清理非强引用的队列
        tryDrainReferenceQueues();
        return null;
    }
	// 在这里map.isExpired(entry, now)满足条件执行清除tryExpireEntries(now)
    if (map.isExpired(entry, now)) {
        tryExpireEntries(now);
        return null;
    }
    return value;
}

LoadingCache<KeyType, ValueType> cache = CacheBuilder.newBuilder()
	// 在写入后的10分钟后自动刷新
    .refreshAfterWrite(10, TimeUnit.MINUTES) 
    .build(new CacheLoader<KeyType, ValueType>() {
        @Override
        public ValueType load(KeyType key) {
            // 缓存项不存在时加载数据的方法
            return loadData(key);
        }

        @Override
        public ListenableFuture<ValueType> reload(KeyType key, ValueType oldValue) throws Exception {
            // 异步刷新缓存项的方法
            // 使用ListenableFuture来异步执行刷新操作
            return listeningExecutorService.submit(() -> loadData(key));
        }
    });