Guava LoadingCache使用记录

LoadingCache可替换Map作为系统的缓存，相比于Map提供了数据自动回收功能，当然还有诸如数据删除监听、数据更新等功能，具体使用方式见代码与注释：

package com.zte.sunquan.demo.test;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.cache.RemovalListener;
import com.google.common.cache.RemovalListeners;
import com.google.common.cache.RemovalNotification;
import com.google.common.collect.Lists;
import org.junit.Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Created by sunquan on 2017/11/20.
 */
public class H2Test {
    //simulate data
    List<String> list = Lists.newArrayList("a", "b", "c", "d", "e", "f", "g", "h", "j", "k", "m");

    private String compute(Integer key) {
        System.out.println(Thread.currentThread().getName() + "-compute value with " + key);
        return list.get(key);
    }


    @Test
    public void testCache1() throws ExecutionException {
        Cache<Integer, String> cache = CacheBuilder.<Integer, String>newBuilder().build();
        cache.put(0, "a");
        cache.put(1, "b");
        cache.put(2, "c");
        cache.put(3, "d");
        System.out.println(cache.getIfPresent(0));//a
        System.out.println(cache.getIfPresent(-1));//null
        System.out.println(cache.get(-1, () -> "bb"));//bb （无指定key的value，则执行callable,并将计算值加入缓存）
        System.out.println(cache.getIfPresent(-1));//bb
    }

    @Test
    public void testCache3() throws ExecutionException, InterruptedException {
        LoadingCache<Integer, String> cache = CacheBuilder.<Integer, String>newBuilder()
                .build(new CacheLoader<Integer, String>() {
                    //cache for what
                    public String load(Integer key) {
                        return compute(key);
                    }
                });
        //每隔1秒进行数据更新，会执行compute重新计算
        ScheduledExecutorService exe = Executors.newScheduledThreadPool(1);
        exe.scheduleAtFixedRate(() -> cache.asMap().keySet().forEach(cache::refresh), 0, 1, TimeUnit.SECONDS);
        System.out.println("v1:" + cache.get(1));
        cache.invalidate(1);//消除key为1的缓存
        Thread.sleep(2000);
        System.out.println("v2:" + cache.get(1));//重新执行compute
    }

    @Test
    public void testCache2() throws ExecutionException, InterruptedException {
        LoadingCache<Integer, String> cache = CacheBuilder.<Integer, String>newBuilder()
                .build(new CacheLoader<Integer, String>() {
                    //cache for what
                    public String load(Integer key) {
                        return compute(key);
                    }
                });
        //每隔1秒进行数据更新，会执行compute重新计算
        ScheduledExecutorService exe = Executors.newScheduledThreadPool(1);
        exe.scheduleAtFixedRate(() -> cache.asMap().keySet().forEach(cache::refresh), 0, 1, TimeUnit.SECONDS);
        System.out.println("v1:" + cache.get(1));
        Thread.sleep(1000);
        System.out.println("v2:" + cache.get(1));
        Thread.sleep(5000);
    }


    @Test
    public void testCache4() throws ExecutionException, InterruptedException {
        //增加缓存值删除监听器
        LoadingCache<Integer, String> cache = CacheBuilder.<Integer, String>newBuilder()
                .removalListener(new RemovalListener<Integer, String>() {
                    @Override
                    public void onRemoval(RemovalNotification<Integer, String> removalNotification) {
                        System.out.println(Thread.currentThread().getName() + "-remove key:" + removalNotification.getKey());
                        System.out.println(Thread.currentThread().getName() + "-remove value:" + removalNotification.getValue());
                    }
                })
                .build(new CacheLoader<Integer, String>() {
                    //cache for what
                    public String load(Integer key) {
                        return compute(key);
                    }
                });
        //每隔1秒进行数据更新，会执行compute重新计算（注意refresh会触发删除操作)
        ScheduledExecutorService exe = Executors.newScheduledThreadPool(1);
        exe.scheduleAtFixedRate(() -> cache.asMap().keySet().forEach(cache::refresh), 0, 1, TimeUnit.SECONDS);
        System.out.println("v1:" + cache.get(1));
        Thread.sleep(1000);
        System.out.println("v2:" + cache.get(1));
        Thread.sleep(3000);

        cache.invalidateAll();//invalidate亦会触发删除操作
        Thread.sleep(3000);
    }

    @Test
    public void testCache5() throws ExecutionException, InterruptedException {
        //增加缓存值删除监听器
        LoadingCache<Integer, String> cache = CacheBuilder.<Integer, String>newBuilder()
                .removalListener(new RemovalListener<Integer, String>() {
                    @Override
                    public void onRemoval(RemovalNotification<Integer, String> removalNotification) {
                        System.out.println(Thread.currentThread().getName() + "-remove key:" + removalNotification.getKey());
                        System.out.println(Thread.currentThread().getName() + "-remove value:" + removalNotification.getValue());
                    }
                }).recordStats()
                .build(new CacheLoader<Integer, String>() {
                    //cache for what
                    public String load(Integer key) {
                        return compute(key);
                    }
                });
        //每隔1秒进行数据更新，会执行compute重新计算（注意refresh会触发删除操作)
        ScheduledExecutorService exe = Executors.newScheduledThreadPool(1);
        exe.scheduleAtFixedRate(() -> cache.asMap().keySet().forEach(cache::refresh), 0, 1, TimeUnit.SECONDS);
        System.out.println("v1:" + cache.get(1));
        Thread.sleep(1000);
        System.out.println("v2:" + cache.get(1));
        Thread.sleep(3000);

        cache.invalidateAll();//invalidate亦会触发删除操作
        Thread.sleep(3000);
        System.out.println(cache.stats());
    }

    @Test
    public void testCache6() throws ExecutionException, InterruptedException {
        RemovalListener<Integer, String> listener = RemovalListeners.asynchronous(new RemovalListener<Integer, String>() {
            @Override
            public void onRemoval(RemovalNotification<Integer, String> removalNotification) {
                System.out.println(Thread.currentThread().getName() + "-remove key:" + removalNotification.getKey());
                System.out.println(Thread.currentThread().getName() + "-remove value:" + removalNotification.getValue());
            }
        }, Executors.newSingleThreadExecutor());
        //增加缓存值删除异步监听器
        LoadingCache<Integer, String> cache = CacheBuilder.<Integer, String>newBuilder()
                .removalListener(listener).recordStats()
                .build(new CacheLoader<Integer, String>() {
                    //cache for what
                    public String load(Integer key) {
                        return compute(key);
                    }
                });
        //每隔1秒进行数据更新，会执行compute重新计算（注意refresh会触发删除操作)
        ScheduledExecutorService exe = Executors.newScheduledThreadPool(1);
        exe.scheduleAtFixedRate(() -> cache.asMap().keySet().forEach(cache::refresh), 0, 1, TimeUnit.SECONDS);
        System.out.println("v1:" + cache.get(1));
        Thread.sleep(1000);
        System.out.println("v2:" + cache.get(1));
        Thread.sleep(3000);

        cache.invalidateAll();//invalidate亦会触发删除操作
        Thread.sleep(3000);
        System.out.println(cache.stats());
        cache.cleanUp();
    }  
}

具体使用，建议加入定时更新（如果compute计算逻辑不固定）

  @Test
    public void testCache7() throws ExecutionException, InterruptedException {
        ScheduledExecutorService exe = Executors.newScheduledThreadPool(1);
        //增加缓存值删除异步监听器
        LoadingCache<Integer, String> cache = CacheBuilder.<Integer, String>newBuilder()
                .build(new CacheLoader<Integer, String>() {
                    //cache for what
                    public String load(Integer key) {
                        return compute(key);
                    }
                });
        //每隔5分钟进行数据更新，会执行compute重新计算（注意refresh会触发删除操作)
        exe.scheduleAtFixedRate(() -> cache.asMap().keySet().forEach(cache::refresh), 0, 1, TimeUnit.MINUTES);
        System.out.println("v1:" + cache.get(1));
        Thread.sleep(1000);
        System.out.println("v2:" + cache.get(1));
        Thread.sleep(3000);
        cache.invalidateAll();//invalidate亦会触发删除操作
        Thread.sleep(3000);
        cache.cleanUp();
    }