seleniumselenium12-12 05:54

Guava | 缓存 与 Redis

com.google.common.cache

1、背景

缓存,在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说,cache 就是为了提升系统性能而开辟的一块内存空间。

缓存的主要作用是暂时在内存中保存业务系统的数据处理结果,并且等待下次访问使用。在日常开发的很多场合,由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时,当我们发现我们的系统这个数据请求量很大的时候,频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的瓶颈出现。缓存的作用就是将这些来自不易的数据保存在内存中,当有其他线程或者客户端需要查询相同的数据资源时,直接从缓存的内存块中返回数据,这样不但可以提高系统的响应时间,同时也可以节省对这些数据的处理流程的资源消耗,整体上来说,系统性能会有大大的提升。

缓存在很多系统和架构中都用广泛的应用,例如:

  • CPU缓存
  • 操作系统缓存
  • 本地缓存
  • 分布式缓存
  • HTTP缓存
  • 数据库缓存

等等,可以说在计算机和网络领域,缓存无处不在。可以这么说,只要有硬件性能不对等,涉及到网络传输的地方都会有缓存的身影。

Guava Cache是一个全内存的本地缓存实现,它提供了线程安全的实现机制。整体上来说Guava cache 是本地缓存的不二之选,简单易用,性能好。

2、适用性

Guava Cache 适用于:

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

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

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

3、缓存创建

Guava Cache有两种创建方式:

  • CacheLoader
  • Callable

这两种创建方式有什么异同呢?

两种方式同样按照获取缓存-如果没有-则计算(get-if-absent-compute)的缓存规则对缓存数据进行的处理的。

不同之处在于:在缓存中没有得到value的时候,CacheLoader会定义一个比较宽泛的、统一的统一的根据key值load value的方法,而Callablee的方式较为灵活,允许你在get的时候指定。

CacheLoader

public void testCacheLoader() throws ExecutionException{
    LoadingCache<String,String> cahceBuilder = CacheBuilder
            .newBuilder()
            .build(new CacheLoader<String, String>() {
                // 在load方法中定义value的加载方法;
                // 这个方法要么返回已经缓存的值,要么使用 CacheLoader 向缓存原子地加载新值
                @Override
                public String load(String key) throws Exception {
                    String strProValue="hello " + key + "!";
                    return strProValue;
                }
                // 默认情况下,对每个不在缓存中的键,getAll 方法会单独调用 CacheLoader.load 来加载缓存项。如果批量的加载比多个单独加载更高效,你可以重载 CacheLoader.loadAll 来利用这一点
                @Override
                public Map<String, String> loadAll(Iterable<? extends String> keys) throws Exception {
                    return super.loadAll(keys);
                }
            });
    logger.info("jerry value:"+cahceBuilder.apply("jerry"));
    logger.info(("jerry value:"+cahceBuilder.get("jerry")));
    logger.info(("peida value:"+cahceBuilder.get("peida")));
    logger.info(("peida value:"+cahceBuilder.apply("peida")));
    logger.info(("lisa value:"+cahceBuilder.apply("lisa")));
    cahceBuilder.put("harry", "ssdded");
    logger.info(("harry value:"+cahceBuilder.get("harry")));
}

异常
由于 CacheLoader 可能抛出异常,LoadingCache.get(K)也声明为抛出 ExecutionException 异常。如果你定义的 CacheLoader 没有声明任何检查型异常,则可以通过 getUnchecked(K)查找缓存;但必须注意,一旦 CacheLoader 声明了检查型异常,就不可以调用 getUnchecked(K)。

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

Callable

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

public void testCallable() throws ExecutionException{
    Cache<String, String> cache = CacheBuilder.newBuilder().maximumSize(1000).build();

    // 获取某个key时,在Cache.get中单独为其指定load方法
    String resultVal = cache.get("jerry", new Callable<String>() {
        public String call() {
            String strProValue="hello "+"jerry"+"!";
            return strProValue;
        }
    });
    logger.info("jerry value : " + resultVal);

    // 获取某个key时,在Cache.get中单独为其指定load方法
    resultVal = cache.get("peida", new Callable<String>() {
        public String call() {
            String strProValue="hello "+"peida"+"!";
            return strProValue;
        }
    });
    logger.info("peida value : " + resultVal);
}

显式插入

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

cache的参数说明:

回收的参数(这些参数在缓存回收时发挥作用):
  1. 大小的设置:CacheBuilder.maximumSize(long) CacheBuilder.weigher(Weigher) CacheBuilder.maxumumWeigher(long)
  2. 时间:expireAfterAccess(long, TimeUnit) expireAfterWrite(long, TimeUnit)
  3. 引用:CacheBuilder.weakKeys() CacheBuilder.weakValues() CacheBuilder.softValues()
  4. 明确的删除:invalidate(key) invalidateAll(keys) invalidateAll()
  5. 删除监听器:CacheBuilder.removalListener(RemovalListener)

4、缓存回收

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

  • 基于容量回收
  • 定时回收
  • 基于引用回收

基于容量的回收(size-based eviction)

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

LoadingCache<String,String> cahceBuilder = CacheBuilder
  .newBuilder()
  .maximumSize(10000)
  .build(new CacheLoader<String, String>() {
            ... ...
});

定时回收(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]、键和值。

下面是一个数据库连接缓存的例子:

public void testRemovalListener(){
    class DatabaseConnection{
        // 实现省略
        DatabaseConnection(String conn){}
        void close(){}
    }
    // 创建loader
    CacheLoader<String, DatabaseConnection> loader = new CacheLoader<String, DatabaseConnection> () {
        public DatabaseConnection load(String key) throws Exception {
            return new DatabaseConnection(key);
        }
    };
    // 创建移除监听器
    RemovalListener<String, DatabaseConnection> removalListener = new RemovalListener<String, DatabaseConnection>() {
        public void onRemoval(RemovalNotification<String, DatabaseConnection> notification) {
            DatabaseConnection conn = notification.getValue();
            conn.close(); // tear down properly
        }
    };

    Cache<String, DatabaseConnection> cache = CacheBuilder.newBuilder()
            .expireAfterWrite(2, TimeUnit.MINUTES)
            .removalListener(removalListener)
            .build(loader);
}

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

清理什么时候发生?

使用 CacheBuilder 构建的缓存不会"自动"执行清理和回收工作,也不会在某个缓存项过期后马上清理,也没有诸如此类的清理机制。相反,它会在写操作时顺带做少量的维护工作,或者偶尔在读操作时做——如果写操作实在太少的话。
这样做的原因在于:如果要自动地持续清理缓存,就必须有一个线程,这个线程会和用户操作竞争共享锁。此外,某些环境下线程创建可能受限制,这样 CacheBuilder 就不可用了。
相反,我们把选择权交到你手里。如果你的缓存是高吞吐的,那就无需担心缓存的维护和清理等工作。如果你的缓存只会偶尔有写操作,而你又不想清理工作阻碍了读操作,那么可以创建自己的维护线程,以固定的时间间隔调用 Cache.cleanUp()。ScheduledExecutorService 可以帮助你很好地实现这样的定时调度。

刷新

刷新和回收不太一样。正如 LoadingCache.refresh(K)所声明,刷新表示为键加载新值,这个过程可以是异步的。在刷新操作进行时,缓存仍然可以向其他线程返回旧值,而不像回收操作,读缓存的线程必须等待新值加载完成。
如果刷新过程抛出异常,缓存将保留旧值,而异常会在记录到日志后被丢弃。

  • 重载 CacheLoader.reload(K, V)可以扩展刷新时的行为,这个方法允许开发者在计算新值时使用旧的值。
  • CacheBuilder.refreshAfterWrite(long, TimeUnit)可以为缓存增加自动定时刷新功能。和 expireAfterWrite相反,refreshAfterWrite 通过定时刷新可以让缓存项保持可用,但请注意:缓存项只有在被检索时才会真正刷新(如果 CacheLoader.refresh 实现为异步,那么检索不会被刷新拖慢)。因此,如果你在缓存上同时声明 expireAfterWrite 和 refreshAfterWrite,缓存并不会因为刷新盲目地定时重置,如果缓存项没有被检索,那刷新就不会真的发生,缓存项在过期时间后也变得可以回收。

5、其他特性

统计

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()不会重置缓存项的读取时间。

中断

6、Guava Cache的不足之处

  • 是单个应用运行时的本地缓存,数据没有持久化存放到文件或外部服务器
  • 单机缓存,受机器内存限制,重启应用缓存数据会丢失,应用分布式部署会出现缓存数据不一致的情况
  • 分布式部署时如何保持缓存的一致性?

7、Redis

Redis是一个开源的/使用C写的基于内存的、支持网络的、可持久化的、日志型的、提供多种语言API的Key-Value数据库。

Redis的特点
  • KV NoSQL
  • 缓存在内存
  • 支持多种数据结构
  • 可持久化:AOF / RDB
  • 高性能、高可靠
  • 支持主从复制
    [ 主从复制 ] 是用来建立一个和主数据库完全一样的数据库环境,称为从数据库;主数据库一般是实时的业务数据库,从数据库的作用和使用场合一般有几个: 一是作为后备数据库,主数据库服务器故障后,可切换到从数据库继续工作; 二是可在从数据库作备份、数据统计等工作,这样不影响主数据库的性能;
  • 支持事务
Redis的下载安装
公司Redis使用指南

由DBA维护.

官场书屋二维码

小额赞赏

000
评论