简单介绍

Caffeine是新出现的一个高性能的Java缓存，有了它完全可以代替Guava Cache，来实现更加高效的缓存；Caffeine采用了W-TinyLFU回收策略，集合了LRU和LFU的优点，提供了一个最佳的命中率，在效率上可以秒杀Guava Cache，下面盗取一个来自网络的性能比较的截图：

如何使用

Caffeine使用非常简单，跟Guava Cache的API使用几乎一致，下面就话不多说直接，进入代码使用和学习中。

手动加载

import java.util.concurrent.TimeUnit;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

public class CaffeineManualLoadTest {

	public static void main(String[] args) {
		// 手动加载
		Cache<String, Object> manualCache = Caffeine.newBuilder()
				.expireAfterWrite(5, TimeUnit.SECONDS)
				.build();
		String key = "test1";
		// 根据key查询一个缓存，如果没有则调用createTestValue方法将返回值写到缓存
		// 如果createTestValue方法返回空，则get方法返回空
		// 如果createTestValue方法抛出异常，则get方法返回异常
		Object oj = manualCache.get(key, k -> createTestValue(k));
		System.out.println("oj = " + oj);
		// 将一个值写入缓存，如果存在就会覆盖掉已经存在的值
		manualCache.put(key, "hello world.");
		oj = manualCache.getIfPresent(key);
		System.out.println("oj = " + oj);
		// 删除一个缓存
		manualCache.invalidate(key);
		oj = manualCache.getIfPresent(key);
		System.out.println("oj = " + oj);
		
	}

	private static Object createTestValue(String k) {
		return null;
	}

}

同步加载

import java.util.concurrent.TimeUnit;

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;

public class CaffeineLoadingTest {

	public static void main(String[] args) {
		// 同步加载
		LoadingCache<String, Object> loadingCache = Caffeine.newBuilder()
				.expireAfterWrite(10, TimeUnit.SECONDS)
				.build(key -> createTestValue(key));
		
		String key = "test1";
		// 在获取指定key的值的时候
		// 如果没有获取到则通过在构建同步缓存的时候调用createTestValue方法写入方法值
		Object oj = loadingCache.get(key);
		System.out.println("oj : " + oj);
	}

	private static Object createTestValue(String k) {
		return k;
	}

}

异步加载

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

import com.github.benmanes.caffeine.cache.AsyncLoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;

public class CaffeineAsyncLoadTest {

	public static void main(String[] args) {
		// 异步加载
		AsyncLoadingCache<String, Object> asyncLoadingCache = Caffeine.newBuilder()
				.expireAfterWrite(60, TimeUnit.SECONDS)
				.buildAsync(key -> createTestValue(key));
		String key = "test1";
		// 查询并且在指定的key不存在的时候，通过异步的方式来构建缓存，返回的是CompletableFuture
		CompletableFuture<Object> futrueOj = asyncLoadingCache.get(key);
	}

	private static Object createTestValue(String k) {
		return "jingjing say: hello world.";
	}

}

驱逐策略

1.基于大小：Caffeine.maximumSize(long)，Caffeine.maximumWeight(long)；注意这两个不能同时使用。

2.基于时间：可以设置为基于秒，分等等时间策略。

3.基于引用：用到了Java中的强引用，软引用，弱引用的概念去实现的。