Google Guava 工具集__2__Cache 缓存使用

Google Guava 工具集 博客栏目链接：Google Guava 博客栏目

博客栏目涉及演示代码 GitHub 地址： 点击打开Guava 演示代码包

范例

01 LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
02         .maximumSize(1000)
03         .expireAfterWrite(10, TimeUnit.MINUTES)
04         .removalListener(MY_LISTENER)
05         .build(
06             new CacheLoader<Key, Graph>() {
07                 public Graph load(Key key) throws AnyException {
08                     return createExpensiveGraph(key);
09                 }
10         });

适用性

缓存在很多场景下都是相当有用的。例如，计算或检索一个值的代价很高，并且对同样的输入需要不止一次获取值的时候，就应当考虑使用缓存。

Guava Cache与ConcurrentMap很相似，但也不完全一样。最基本的区别是ConcurrentMap会一直保存所有添加的元素，直到显式地移除。相对地，Guava Cache为了限制内存占用，通常都设定为自动回收元素。在某些场景下，尽管LoadingCache 不回收元素，它也是很有用的，因为它会自动加载缓存。

通常来说，Guava Cache适用于：

• 你愿意消耗一些内存空间来提升速度。
• 你预料到某些键会被查询一次以上。
• 缓存中存放的数据总量不会超出内存容量。（Guava Cache是单个应用运行时的本地缓存。它不把数据存放到文件或外部服务器。如果这不符合你的需求，请尝试Memcached这类工具）

如果你的场景符合上述的每一条，Guava Cache就适合你。

如同范例代码展示的一样，Cache实例通过CacheBuilder生成器模式获取，但是自定义你的缓存才是最有趣的部分。

注：如果你不需要Cache中的特性，使用ConcurrentHashMap有更好的内存效率——但Cache的大多数特性都很难基于旧有的ConcurrentMap复制，甚至根本不可能做到。

加载

在使用缓存前，首先问自己一个问题：有没有合理的默认方法来加载或计算与键关联的值？如果有的话，你应当使用CacheLoader。如果没有，或者你想要覆盖默认的加载运算，同时保留"获取缓存-如果没有-则计算"[get-if-absent-compute]的原子语义，你应该在调用get时传入一个Callable实例。缓存元素也可以通过Cache.put方法直接插入，但自动加载是首选的，因为它可以更容易地推断所有缓存内容的一致性。

CacheLoader

LoadingCache是附带CacheLoader构建而成的缓存实现。创建自己的CacheLoader通常只需要简单地实现V load(K key) throws Exception方法。例如，你可以用下面的代码构建LoadingCache：

01 LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
02         .maximumSize(1000)
03         .build(
04             new CacheLoader<Key, Graph>() {
05                 public Graph load(Key key) throws AnyException {
06                     return createExpensiveGraph(key);
07                 }
08             });
09
10 ...
11 try {
12     return graphs.get(key);
13 } catch (ExecutionException e) {
14     throw new OtherException(e.getCause());
15 }

从LoadingCache查询的正规方式是使用get(K)方法。这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地加载新值。由于CacheLoader可能抛出异常，LoadingCache.get(K)也声明为抛出ExecutionException异常。如果你定义的CacheLoader没有声明任何检查型异常，则可以通过getUnchecked(K)查找缓存；但必须注意，一旦CacheLoader声明了检查型异常，就不可以调用getUnchecked(K)。

01 LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
02         .expireAfterAccess(10, TimeUnit.MINUTES)
03         .build(
04             new CacheLoader<Key, Graph>() {
05                 public Graph load(Key key) { // no checked exception
06                     return createExpensiveGraph(key);
07                 }
08             });
09
10 ...
11 return graphs.getUnchecked(key);

getAll(Iterable<? extends K>)方法用来执行批量查询。默认情况下，对每个不在缓存中的键，getAll方法会单独调用CacheLoader.load来加载缓存项。如果批量的加载比多个单独加载更高效，你可以重载CacheLoader.loadAll来利用这一点。getAll(Iterable)的性能也会相应提升。

注：CacheLoader.loadAll的实现可以为没有明确请求的键加载缓存值。例如，为某组中的任意键计算值时，能够获取该组中的所有键值，loadAll方法就可以实现为在同一时间获取该组的其他键值。校注：getAll(Iterable<? extends K>)方法会调用loadAll，但会筛选结果，只会返回请求的键值对。

Callable

所有类型的Guava Cache，不管有没有自动加载功能，都支持get(K, Callable<V>)方法。这个方法返回缓存中相应的值，或者用给定的Callable运算并把结果加入到缓存中。在整个加载方法完成前，缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式"如果有缓存则返回；否则运算、缓存、然后返回"。

01 Cache<Key, Graph> cache = CacheBuilder.newBuilder()
02         .maximumSize(1000)
03         .build(); // look Ma, no CacheLoader
04 ...
05 try {
06     // If the key wasn't in the "easy to compute" group, we need to
07     // do things the hard way.
08     cache.get(key, new Callable<Key, Graph>() {
09         @Override
10         public Value call() throws AnyException {
11             return doThingsTheHardWay(key);
12         }
13     });
14 } catch (ExecutionException e) {
15     throw new OtherException(e.getCause());
16 }

显式插入

使用cache.put(key, value)方法可以直接向缓存中插入值，这会直接覆盖掉给定键之前映射的值。使用Cache.asMap()视图提供的任何方法也能修改缓存。但请注意，asMap视图的任何方法都不能保证缓存项被原子地加载到缓存中。进一步说，asMap视图的原子运算在Guava Cache的原子加载范畴之外，所以相比于Cache.asMap().putIfAbsent(K,
V)，Cache.get(K, Callable<V>) 应该总是优先使用。

缓存回收

一个残酷的现实是，我们几乎一定没有足够的内存缓存所有数据。你你必须决定：什么时候某个缓存项就不值得保留了？Guava Cache提供了三种基本的缓存回收方式：基于容量回收、定时回收和基于引用回收。

基于容量的回收（size-based eviction）

如果要规定缓存项的数目不超过固定值，只需使用CacheBuilder.maximumSize(long)。缓存将尝试回收最近没有使用或总体上很少使用的缓存项。——警告：在缓存项的数目达到限定值之前，缓存就可能进行回收操作——通常来说，这种情况发生在缓存项的数目逼近限定值时。

另外，不同的缓存项有不同的“权重”（weights）——例如，如果你的缓存值，占据完全不同的内存空间，你可以使用CacheBuilder.weigher(Weigher)指定一个权重函数，并且用CacheBuilder.maximumWeight(long)指定最大总重。在权重限定场景中，除了要注意回收也是在重量逼近限定值时就进行了，还要知道重量是在缓存创建时计算的，因此要考虑重量计算的复杂度。

01 LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
02         .maximumWeight(100000)
03         .weigher(new Weigher<Key, Graph>() {
04             public int weigh(Key k, Graph g) {
05                 return g.vertices().size();
06             }
07         })
08         .build(
09             new CacheLoader<Key, Graph>() {
10                 public Graph load(Key key) { // no checked exception
11                     return createExpensiveGraph(key);
12                 }
13             });

定时回收（Timed Eviction）

CacheBuilder提供两种定时回收的方法：

• expireAfterAccess(long, TimeUnit)：缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。
• expireAfterWrite(long, TimeUnit)：缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。

如下文所讨论，定时回收周期性地在写操作中执行，偶尔在读操作中执行。

测试定时回收

对定时回收进行测试时，不一定非得花费两秒钟去测试两秒的过期。你可以使用Ticker接口和CacheBuilder.ticker(Ticker)方法在缓存中自定义一个时间源，而不是非得用系统时钟。

基于引用的回收（Reference-based Eviction）

通过使用弱引用的键、或弱引用的值、或软引用的值，Guava Cache可以把缓存设置为允许垃圾回收：

• CacheBuilder.weakKeys()：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用键的缓存用==而不是equals比较键。
• CacheBuilder.weakValues()：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用值的缓存用==而不是equals比较值。
• CacheBuilder.softValues()：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。考虑到使用软引用的性能影响，我们通常建议使用更有性能预测性的缓存大小限定（见上文，基于容量回收）。使用软引用值的缓存同样用==而不是equals比较值。

显式清除

任何时候，你都可以显式地清除缓存项，而不是等到它被回收：

• 个别清除：Cache.invalidate(key)
• 批量清除：Cache.invalidateAll(keys)
• 清除所有缓存项：Cache.invalidateAll()

移除监听器

通过CacheBuilder.removalListener(RemovalListener)，你可以声明一个监听器，以便缓存项被移除时做一些额外操作。缓存项被移除时，RemovalListener会获取移除通知[RemovalNotification]，其中包含移除原因[RemovalCause]、键和值。

请注意，RemovalListener抛出的任何异常都会在记录到日志后被丢弃[swallowed]。

01 CacheLoader<Key, DatabaseConnection> loader = new CacheLoader<Key, DatabaseConnection> () {
02     public DatabaseConnection load(Key key) throws Exception {
03         return openConnection(key);
04     }
05 };
06
07 RemovalListener<Key, DatabaseConnection> removalListener = newRemovalListener<Key, DatabaseConnection>() {
08     public void onRemoval(RemovalNotification<Key, DatabaseConnection> removal) {
09         DatabaseConnection conn = removal.getValue();
10         conn.close(); // tear down properly
11     }
12 };
13
14 return CacheBuilder.newBuilder()
15     .expireAfterWrite(2, TimeUnit.MINUTES)
16     .removalListener(removalListener)
17     .build(loader);

警告：默认情况下，监听器方法是在移除缓存时同步调用的。因为缓存的维护和请求响应通常是同时进行的，代价高昂的监听器方法在同步模式下会拖慢正常的缓存请求。在这种情况下，你可以使用RemovalListeners.asynchronous(RemovalListener, Executor)把监听器装饰为异步操作。

清理什么时候发生？

使用CacheBuilder构建的缓存不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，也没有诸如此类的清理机制。相反，它会在写操作时顺带做少量的维护工作，或者偶尔在读操作时做——如果写操作实在太少的话。

这样做的原因在于：如果要自动地持续清理缓存，就必须有一个线程，这个线程会和用户操作竞争共享锁。此外，某些环境下线程创建可能受限制，这样CacheBuilder就不可用了。

相反，我们把选择权交到你手里。如果你的缓存是高吞吐的，那就无需担心缓存的维护和清理等工作。如果你的 缓存只会偶尔有写操作，而你又不想清理工作阻碍了读操作，那么可以创建自己的维护线程，以固定的时间间隔调用Cache.cleanUp()。ScheduledExecutorService可以帮助你很好地实现这样的定时调度。

刷新 - 修改 Key 对应的 Value

刷新和回收不太一样。正如LoadingCache.refresh(K)所声明，刷新表示为键加载新值，这个过程可以是异步的。在刷新操作进行时，缓存仍然可以向其他线程返回旧值，而不像回收操作，读缓存的线程必须等待新值加载完成。

如果刷新过程抛出异常，缓存将保留旧值，而异常会在记录到日志后被丢弃[swallowed]。

重载CacheLoader.reload(K, V)可以扩展刷新时的行为，这个方法允许开发者在计算新值时使用旧的值。

01 //有些键不需要刷新，并且我们希望刷新是异步完成的
02 LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
03         .maximumSize(1000)
04         .refreshAfterWrite(1, TimeUnit.MINUTES)
05         .build(
06             new CacheLoader<Key, Graph>() {
07                 public Graph load(Key key) { // no checked exception
08                     return getGraphFromDatabase(key);
09                 }
10
11                 public ListenableFuture<Key, Graph> reload(final Key key, Graph prevGraph) {
12                     if (neverNeedsRefresh(key)) {
13                         return Futures.immediateFuture(prevGraph);
14                     }else{
15                         // asynchronous!
16                         ListenableFutureTask<Key, Graph> task=ListenableFutureTask.create(new Callable<Key, Graph>() {
17                             public Graph call() {
18                                 return getGraphFromDatabase(key);
19                             }
20                         });
21                         executor.execute(task);
22                         return task;
23                     }
24                 }
25             });

CacheBuilder.refreshAfterWrite(long, TimeUnit)可以为缓存增加自动定时刷新功能。和expireAfterWrite相反，refreshAfterWrite通过定时刷新可以让缓存项保持可用，但请注意：缓存项只有在被检索时才会真正刷新（如果CacheLoader.refresh实现为异步，那么检索不会被刷新拖慢）。因此，如果你在缓存上同时声明expireAfterWrite和refreshAfterWrite，缓存并不会因为刷新盲目地定时重置，如果缓存项没有被检索，那刷新就不会真的发生，缓存项在过期时间后也变得可以回收。

其他特性

统计

CacheBuilder.recordStats()用来开启Guava Cache的统计功能。统计打开后，Cache.stats()方法会返回CacheStats对象以提供如下统计信息：

• hitRate()：缓存命中率；

• averageLoadPenalty()：加载新值的平均时间，单位为纳秒；

• evictionCount()：缓存项被回收的总数，不包括显式清除。

此外，还有其他很多统计信息。这些统计信息对于调整缓存设置是至关重要的，在性能要求高的应用中我们建议密切关注这些数据。

asMap视图

asMap视图提供了缓存的ConcurrentMap形式，但asMap视图与缓存的交互需要注意：

• cache.asMap()包含当前所有加载到缓存的项。因此相应地，cache.asMap().keySet()包含当前所有已加载键;
• asMap().get(key)实质上等同于cache.getIfPresent(key)，而且不会引起缓存项的加载。这和Map的语义约定一致。
• 所有读写操作都会重置相关缓存项的访问时间，包括Cache.asMap().get(Object)方法和Cache.asMap().put(K, V)方法，但不包括Cache.asMap().containsKey(Object)方法，也不包括在Cache.asMap()的集合视图上的操作。比如，遍历Cache.asMap().entrySet()不会重置缓存项的读取时间。

中断

缓存加载方法（如Cache.get）不会抛出InterruptedException。我们也可以让这些方法支持InterruptedException，但这种支持注定是不完备的，并且会增加所有使用者的成本，而只有少数使用者实际获益。详情请继续阅读。

Cache.get请求到未缓存的值时会遇到两种情况：当前线程加载值；或等待另一个正在加载值的线程。这两种情况下的中断是不一样的。等待另一个正在加载值的线程属于较简单的情况：使用可中断的等待就实现了中断支持；但当前线程加载值的情况就比较复杂了：因为加载值的CacheLoader是由用户提供的，如果它是可中断的，那我们也可以实现支持中断，否则我们也无能为力。

如果用户提供的CacheLoader是可中断的，为什么不让Cache.get也支持中断？从某种意义上说，其实是支持的：如果CacheLoader抛出InterruptedException，Cache.get将立刻返回（就和其他异常情况一样）；此外，在加载缓存值的线程中，Cache.get捕捉到InterruptedException后将恢复中断，而其他线程中InterruptedException则被包装成了ExecutionException。

原则上，我们可以拆除包装，把ExecutionException变为InterruptedException，但这会让所有的LoadingCache使用者都要处理中断异常，即使他们提供的CacheLoader不是可中断的。如果你考虑到所有非加载线程的等待仍可以被中断，这种做法也许是值得的。但许多缓存只在单线程中使用，它们的用户仍然必须捕捉不可能抛出的InterruptedException异常。即使是那些跨线程共享缓存的用户，也只是有时候能中断他们的get调用，取决于那个线程先发出请求。

对于这个决定，我们的指导原则是让缓存始终表现得好像是在当前线程加载值。这个原则让使用缓存或每次都计算值可以简单地相互切换。如果老代码（加载值的代码）是不可中断的，那么新代码（使用缓存加载值的代码）多半也应该是不可中断的。

如上所述，Guava Cache在某种意义上支持中断。另一个意义上说，Guava Cache不支持中断，这使得LoadingCache成了一个有漏洞的抽象：当加载过程被中断了，就当作其他异常一样处理，这在大多数情况下是可以的；但如果多个线程在等待加载同一个缓存项，即使加载线程被中断了，它也不应该让其他线程都失败（捕获到包装在ExecutionException里的InterruptedException），正确的行为是让剩余的某个线程重试加载。为此，我们记录了一个bug。然而，与其冒着风险修复这个bug，我们可能会花更多的精力去实现另一个建议AsyncLoadingCache，这个实现会返回一个有正确中断行为的Future对象。

• 原创文章转载出处并发编程网：[Google Guava] 3-缓存

演示代码

/**
 * Guava Cache Example
 *
 * @author wei.Li by 14-8-27.
 */
public class LoadCache {

    private static final org.slf4j.Logger LOGGER
            = LoggerFactory.getLogger(LoadCache.class);

    static LoadingCache loadingCache = null;
    static ExecutorService threadPool = Executors.newCachedThreadPool();
    private static boolean isRunTest = true;

    /**
     * 构建缓存
     */
    private static void builderLoadingCache() {

        loadingCache = CacheBuilder.newBuilder()
                .initialCapacity(100)
                .concurrencyLevel(1)
                        //.maximumSize(3000)

                        //缓存项在给定时间内没有被读/写访问，则回收。
                        // 请注意这种缓存的回收顺序和基于大小回收一样。
                .expireAfterAccess(3, TimeUnit.SECONDS)

                        //缓存项在给定时间内没有被写访问（创建或覆盖），则回收。
                        // 如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。
                        //.expireAfterWrite(2, TimeUnit.SECONDS)

                        //可以为缓存增加自动定时刷新功能。和expireAfterWrite相反，refreshAfterWrite通过定时刷新可以让缓存项保持可用.
                        // 但请注意：缓存项只有在被检索时才会真正刷新（如果CacheLoader.refresh实现为异步，那么检索不会被刷新拖慢）。
                        // 因此，如果你在缓存上同时声明expireAfterWrite和refreshAfterWrite，缓存并不会因为刷新盲目地定时重置.
                        // 如果缓存项没有被检索，那刷新就不会真的发生,缓存项在过期时间后也变得可以回收。
                .refreshAfterWrite(3, TimeUnit.SECONDS)

                .removalListener(removalListenerBuild())

                .ticker(new Ticker() {
                    @Override
                    public long read() {
                        return 500L;
                    }
                })

                        // 使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。
                        // 因为垃圾回收仅依赖恒等式（==），使用弱引用键的缓存用==而不是equals比较键。
                        //.weakKeys()
                        //.weakValues()
                        // 使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。
                        // 考虑到使用软引用的性能影响，我们通常建议使用更有性能预测性的缓存大小限定（基于容量回收）
                        // 使用软引用值的缓存同样用==而不是equals比较值。
                        //  .softValues()

                        //开启状态监控
                .recordStats()

                .build(cacheLoaderBuild());

    }

    /**
     * 缓存项被移除时做一些额外操作。
     * 警告：默认情况下，监听器方法是在移除缓存时同步调用的。
     * 因为缓存的维护和请求响应通常是同时进行的，代价高昂的监听器方法在同步模式下会拖慢正常的缓存请求。
     * 在这种情况下，你可以使用RemovalListeners.asynchronous(RemovalListener, Executor)把监听器装饰为异步操作。
     *
     * @return RemovalListener
     */
    private static RemovalListener removalListenerBuild() {
        return RemovalListeners.asynchronous(new RemovalListener<String, String>() {
            @Override
            public void onRemoval(RemovalNotification<String, String> notification) {
                LOGGER.info("onRemoval ... , notification: <{}>", notification.toString());
            }
        }, Executors.newCachedThreadPool());
    }

    /**
     * 有些键不需要刷新，并且我们希望刷新是异步完成的
     *
     * @return CacheLoader
     */
    private static CacheLoader cacheLoaderBuild() {

        return new CacheLoader<String, String>() {
            /**
             * get 时候如果 key 不存在，load 进缓存
             *
             * @param key key
             * @return key 值对应的 value
             * @throws Exception
             */
            @Override
            public String load(String key) throws Exception {
                // LOGGER.info("load(String key) run ... , key: <{}>", key);
                return getValueForKey(key);
            }

            /**
             * 修改 key 对应的 value 值
             * 重载CacheLoader.reload(K, V)可以扩展刷新时的行为，这个方法允许开发者在计算新值时使用旧的值。
             * @param key 刷新的 key 值
             * @param oldValue 对应的 value 值
             * @return task
             */
            @Override
            public ListenableFuture<String> reload(final String key, String oldValue) {

                if (key.contains("2")) {
                    return Futures.immediateFuture(oldValue);
                } else {
                    // asynchronous!
                    ListenableFutureTask<String> task
                            = ListenableFutureTask.create(new Callable<String>() {
                        public String call() {
                            return oldValue + "reload";
                        }
                    });
                    Executors.newCachedThreadPool().execute(task);
                    return task;
                }
            }

            @Override
            public Map<String, String> loadAll(Iterable<? extends String> keys) throws Exception {
                return super.loadAll(keys);
            }
        };
    }


    /**
     * 由 key 计算对应的 value
     *
     * @param key
     * @return
     */
    private static String getValueForKey(String key) {
        checkNotNull(key);
        return key + "_" + key;
    }


    /**
     * 获取缓存状态
     */
    private static void getCacheStats() {
        LOGGER.info("loadingCache.stats().toString() is : <{}>"
                , loadingCache.stats());
        LOGGER.info("loadingCache.asMap().toString() is : <{}>"
                , loadingCache.asMap());
    }

    /**
     * 添加测试数据到缓存线程
     * 修改部分缓存的值
     */
    private static class AddOperationRun implements Runnable {

        @Override
        public void run() {
            while (isRunTest) {
                try {
                    for (int i = 0; i < 10; i++) {
                        loadingCache.get(String.valueOf(new Random().nextInt(5)));
                    }
                    //刷新 key 值 , 如果不存在load进缓存，否则进行刷新操作
                    loadingCache.refresh(String.valueOf(new Random().nextInt(10)));
                    Thread.sleep(2000L);
                } catch (ExecutionException | InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    private static void runTest() {

        //启动查询缓存数据线程
        for (int i = 0; i < 4; i++) {
            threadPool.execute(new AddOperationRun());
        }

        //定时器输出缓存状态
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                getCacheStats();
            }
        }, 1000L, 2000L);

        //定时器停止测试任务
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                isRunTest = false;
                threadPool.shutdown();
            }
        }, 1000 * 150L);

    }

    public static void main(String[] args) {
        builderLoadingCache();

        runTest();
    }
}

部分运行结果

...

...

...

loadingCache.stats().toString() is : <CacheStats{hitCount=70, missCount=10, loadSuccessCount=13, loadExceptionCount=0, totalLoadTime=69408000, evictionCount=0}>
loadingCache.asMap().toString() is : <{3=3_3, 8=8_8, 2=2_2, 0=0_0reload, 1=1_1reloadreload, 7=7_7, 4=4_4reload}>
onRemoval ... , notification: <2=2_2>
onRemoval ... , notification: <0=0_0reload>
onRemoval ... , notification: <3=3_3>
loadingCache.stats().toString() is : <CacheStats{hitCount=110, missCount=10, loadSuccessCount=17, loadExceptionCount=0, totalLoadTime=70500000, evictionCount=0}>
loadingCache.asMap().toString() is : <{3=3_3reload, 8=8_8, 2=2_2, 9=9_9, 0=0_0reloadreload, 1=1_1reloadreload, 7=7_7, 4=4_4reload}>
onRemoval ... , notification: <2=2_2>
onRemoval ... , notification: <7=7_7>
onRemoval ... , notification: <0=0_0reloadreload>
loadingCache.stats().toString() is : <CacheStats{hitCount=150, missCount=10, loadSuccessCount=20, loadExceptionCount=0, totalLoadTime=72473000, evictionCount=0}>
loadingCache.asMap().toString() is : <{3=3_3reload, 8=8_8, 2=2_2, 9=9_9, 0=0_0reloadreloadreload, 1=1_1reloadreload, 7=7_7reload, 4=4_4reload}>
onRemoval ... , notification: <2=2_2>
onRemoval ... , notification: <8=8_8>
onRemoval ... , notification: <0=0_0reloadreloadreload>
loadingCache.stats().toString() is : <CacheStats{hitCount=190, missCount=10, loadSuccessCount=23, loadExceptionCount=0, totalLoadTime=73716000, evictionCount=0}>
loadingCache.asMap().toString() is : <{3=3_3reload, 8=8_8reload, 2=2_2, 9=9_9, 0=0_0reloadreloadreloadreload, 1=1_1reloadreload, 7=7_7reload, 4=4_4reload}>
onRemoval ... , notification: <2=2_2>
onRemoval ... , notification: <3=3_3reload>
onRemoval ... , notification: <4=4_4reload>
loadingCache.stats().toString() is : <CacheStats{hitCount=230, missCount=10, loadSuccessCount=27, loadExceptionCount=0, totalLoadTime=75795000, evictionCount=0}>
loadingCache.asMap().toString() is : <{3=3_3reloadreload, 8=8_8reload, 2=2_2, 9=9_9, 0=0_0reloadreloadreloadreload, 1=1_1reloadreload, 7=7_7reload, 4=4_4reloadreload, 6=6_6}>
onRemoval ... , notification: <4=4_4reloadreload>
onRemoval ... , notification: <7=7_7reload>
onRemoval ... , notification: <6=6_6>
onRemoval ... , notification: <8=8_8reload>
loadingCache.stats().toString() is : <CacheStats{hitCount=270, missCount=10, loadSuccessCount=31, loadExceptionCount=0, totalLoadTime=80805000, evictionCount=0}>
loadingCache.asMap().toString() is : <{3=3_3reloadreload, 8=8_8reloadreload, 2=2_2, 9=9_9, 0=0_0reloadreloadreloadreload, 1=1_1reloadreload, 7=7_7reloadreload, 4=4_4reloadreloadreload, 6=6_6reload}>

...

...

...