Redis教程

caffine 本地缓存 和 currenthashmap 缓存 以及 redis 缓存 关系

本文主要是介绍caffine 本地缓存 和 currenthashmap 缓存 以及 redis 缓存 关系,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Caffeine 缓存 和 java集合缓存 以及 redis 缓存 关系

​ 先比较前两着,比较显著的区别:1,Caffeine 缓存可以设定删除时间等删除条件、ConcurrentMap 代表的只JAVA集合类等只能动态添加保存,除非显示的删除(有可能内存溢出)。

2, Caffeine 的读写能力显著高于ConcurrentHashMap 。

3,ConcurrentMapCacheManager 这一类基本都是基于本地内存的缓存,不支持分布式,当然caffeine也是不支持分布式的,著名的支持分布式缓存是redis,,其他的都是应用中的 基于本地应用 的缓存,即本地缓存

​ 常用的spring Cache :

public enum CacheType {
	GENERIC, // 使用的SimpleCacheManager(自己手动指定Cache,可任意类型Cache实现哦)
	JCACHE, // 使用org.springframework.cache.jcache.JCacheCacheManager
	EHCACHE, // 使用org.springframework.cache.ehcache.EhCacheCacheManager
	HAZELCAST, // 使用com.hazelcast.spring.cache.HazelcastCacheManager
	INFINISPAN, // 使用org.infinispan.spring.provider.SpringEmbeddedCacheManager
	COUCHBASE, // 使用com.couchbase.client.spring.cache.CouchbaseCacheManager
	REDIS, // 使用org.springframework.data.redis.cache.RedisCacheManager,依赖于RedisTemplate进行操作
	CAFFEINE, // 使用org.springframework.cache.caffeine.CaffeineCacheManager
	@Deprecated
	GUAVA, // 使用org.springframework.cache.guava.GuavaCacheManager,已经过期不推荐使用了
	SIMPLE, // 使用ConcurrentMapCacheManager
	NONE; // 使用NoOpCacheManager,表示禁用缓存
       
}

补充:Memcached,也是高性能、分布式的

​ 简单介绍这几种缓存的特点:

  1. EhCache:一个纯Java的进程内缓存框架,具有快速、精干等特点。因为它是纯Java进程的,所以也是基于本地缓存的。(注意:EhCache2.x和EhCache3.x差异巨大且不兼容)

  2. Hazelcast:基于内存的数据网格。虽然它基于内存,但是分布式应用程序可以使用Hazelcast进行分布式缓存、同步、集群、处理、发布/订阅消息等。(如果你正在寻找基于内存的、高速的、可弹性扩展的、支持分布式的、对开发者友好的NoSQL,Hazelcast是一个很棒的选择,它的理念是用应用服务的内存换取效率,成本较高).

    从com.hazelcast.spring.cache.HazelcastCacheManager这个包名中也能看出,是它自己实现的Spring Cache标准,而不是spring-data帮它实现的(类似MyBatis集成Spring),但它凭借自己的足够优秀,让Spring接受了它

  3. Infinispan:基于Apache 2.0协议的分布式键值存储系统,可以以普通java lib或者独立服务的方式提供服务,支持各种协议(Hot Rod, REST, WebSockets)。支持的高级特性包括:事务、事件通知、高级查询、分布式处理、off-heap及故障迁移。 它按照署模式分为嵌入式(Embedded)模式(基于本地内存)、Client-Server(C\S)模式。

  4. Couchbase:是一个非关系型数据库,它实际上是由couchdb+membase组成,所以它既能像couchdb那样存储json文档(类似MongoDB),也能像membase那样高速存储键值对。(新一代的NoSql数据库,国外挺火的)

  5. Redis:熟悉得不能再熟悉的分布式缓存,只有Client-Server(C\S)模式,单线程让它天生具有线程安全的特性。Java一般使用Jedis/Luttuce来操纵~

  6. Caffeine(咖啡因):Caffeine是使用Java8对Guava缓存的重写版本,一个接近最佳的的缓存库(号称性能最好)。Spring5已经放弃guava,拥抱caffeine,它的API保持了近乎和guava一致,但是性能上碾压它。

  7. guava是谷歌Google Guava工具包的,使用非常广泛。Caffeine长江后浪推前浪,性能上碾压了Guava,是它的替代品。

  8. SIMPLE:略

原文链接:https://blog.csdn.net/f641385712/article/details/94982916

​ 下面简单介绍下几种缓存的特点:

1,Caffeine 缓存

1.1 特点

  • 自动加载条目到缓存中,可选异步方式
  • 可以基于大小剔除
  • 可以设置过期时间,时间可以从上次访问或上次写入开始计算
  • 异步刷新
  • keys自动包装在弱引用中
  • values自动包装在弱引用或软引用中
  • 条目剔除通知
  • 缓存访问统计

1.2 spring-boot 集成caffeine的demo

1.2.1 pom引入
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>3.0.4</version>
        </dependency>
 
		<-- 一般带着这个  !>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
1.2.2 准备cache config配置文件:

下面这段代码相当于在xml配置文件当中声明caffinee cache配置, 即caffiine manager。

@EnableCaching  //这个可以加在启动类,即main哪儿
@Configuration
public class CacheConfig  {

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        // 方案一(常用):定制化缓存Cache
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .initialCapacity(100)
                .maximumSize(10_000))
        // 如果缓存种没有对应的value,通过createExpensiveGraph方法同步加载  buildAsync是异步加载
        //.build(key -> createExpensiveGraph(key))
        ;


        // 方案二:传入一个CaffeineSpec定制缓存,它的好处是可以把配置方便写在配置文件里
        //cacheManager.setCaffeineSpec(CaffeineSpec.parse("initialCapacity=50,maximumSize=500,expireAfterWrite=5s"));
        return cacheManager;
    }

}

使用:在代码中直接使用注入即可

    @Resource
    Cache<Integer, String> deployJobStatusCache;

	// deployJobStatusCache.getIfPresent()

特别注释

1, @Configuration : 指示一个类,或者声明一个或多个@Bean方法,并且可以由Spring容器处理,以便在运行时为这些bean生成BeanDefinition和服务请求。@Configuration 注释的类 类似于于一个 xml 配置文件的存在 ,可以将其理解为一个Xml内容的Java版本, 那么,一些Xml中使用的其他写法可以在其中能直接用。 (https://www.jianshu.com/p/721c76c1529c)

1.3 填充策略

1.3.1 手动填充

此策略,手动将值放入缓存之后再检索。

//step1:初始化
Cache<String, DataObject> cache = Caffeine.newBuilder()
 .expireAfterWrite(1, TimeUnit.MINUTES)
 .maximumSize(100)
 .build();

//get或者put
String key = "A";
DataObject dataObject = cache.getIfPresent(key);
assertNull(dataObject);

cache.put(key, dataObject);
dataObject = cache.getIfPresent(key);  
assertNotNull(dataObject);

我们也可以使用 get 方法获取值,该方法将一个参数为 key 的 Function 作为参数传入。如果缓存中不存在该键,则该函数将用于提供回退值,该值在计算后插入缓存中:

dataObject = cache.get(key, k -> DataObject.get(``"Data for A"``));
 
assertNotNull(dataObject);
assertEquals(``"Data for A"``, dataObject.getData());

get 方法可以原子方式执行计算。这意味着您只进行一次计算 — 即使多个线程同时请求该值。这就是为什么使用 get 优于 getIfPresent。

1.3.2 同步加载

相当于在初始化的时候就缓存赋值,暂不清楚场景!

//step1 : 初始化缓存
LoadingCache<String, DataObject> cache = Caffeine.newBuilder()
 .maximumSize(100)
 .expireAfterWrite(1, TimeUnit.MINUTES)
 .build(k -> DataObject.get("Data for " + k));


1.3.3 异步加载

和前面差不多,暂不清楚场景。

AsyncLoadingCache<String, DataObject> cache = Caffeine.newBuilder()
 .maximumSize(100)
 .expireAfterWrite(1, TimeUnit.MINUTES)
 .buildAsync(k -> DataObject.get("Data for " + k));

1.4 回收策略

1.4.1 基于大小回收

这种回收方式假定当超过配置的缓存大小限制时会发生回收。

1.4.2 基于时间回收

这种回收策略是基于条目的到期时间,有三种类型:

  1. 访问后到期 — 从上次读或写发生后,条目即过期。 .expireAfterAccess(``5``, TimeUnit.MINUTES)

  2. 写入后到期 — 从上次写入发生之后,条目即过期 .expireAfterWrite(``10``, TimeUnit.SECONDS)

  3. 自定义策略 — 到期时间由 Expiry 实现独自计算 ——要初始化自定义策略,我们需要实现 Expiry 接口

    cache = Caffeine.newBuilder().expireAfter(new Expiry<String, DataObject>() {
      @Override
      public long expireAfterCreate(
       String key, DataObject value, long currentTime) {
        return value.getData().length() * 1000;
      }
      @Override
      public long expireAfterUpdate(
       String key, DataObject value, long currentTime, long currentDuration) {
        return currentDuration;
      }
      @Override
      public long expireAfterRead(
       String key, DataObject value, long currentTime, long currentDuration) {
        return currentDuration;
      }
    }).build(k -> DataObject.get("Data for " + k));
    
    1.4.3 基于引用回收

    还未使用过这种: 可以将缓存配置为启用缓存键值的垃圾回收。为此,我们将 key 和 value 配置为 弱引用,并且我们可以仅配置软引用以进行垃圾回收。

1.5 统计

可以定义统计方式等, 记录缓存的使用情况。

2,redis缓存 (简单介绍)

先说下 redis和caffeine的主要区别和联系:

相同点:
两个都是缓存的方式

不同点:
redis是将数据存储到内存里
caffeine是将数据存储在本地应用里

caffeine和redis相比,没有了网络IO上的消耗

联系:
一般将两者结合起来,形成一二级缓存。使用流程大致如下:
去一级缓存中查找数据(caffeine-本地应用内)
如果没有的话,去二级缓存中查找数据(redis-内存)
再没有,再去数据库中查找数据(数据库-磁盘)

img

原文链接:https://blog.csdn.net/qsbbl/article/details/107764058

这篇关于caffine 本地缓存 和 currenthashmap 缓存 以及 redis 缓存 关系的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!