再见,Guava!再见,Ehcache!这才是 Java 本地缓存之王!

esp32-C3固件烧录用户手册 温馨提示:1.esp32-C3 BOOT脚为GPIO9,需要从芯片小板中焊接引出2.芯片小板中已经预留了所有烧录相关的引脚,大家可以按需焊接引线3.程序下载完,使用串口查看log时,需要使用220v供电使用(请务必准守用电安全)。原因:由于插座中包含继电器,计量计等耗电设备,所以usb转串口提供的3.3V电压和电流可能会出现供电不足,表现为usb转串口与电脑连接断断续续,导致无法查看log。 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 10:33 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:blog.youkuaiyun.com/lemon_TT/

article/details/122905113

e69d4aaca32199248c9c2b9f11b5ca24.jpeg


一、Caffeine介绍

1、缓存介绍

缓存(Cache)在代码世界中无处不在。从底层的CPU多级缓存,到客户端的页面缓存,处处都存在着缓存的身影。缓存从本质上来说,是一种空间换时间的手段,通过对数据进行一定的空间安排,使得下次进行数据访问时起到加速的效果。

就Java而言,其常用的缓存解决方案有很多,例如数据库缓存框架EhCache,分布式缓存Memcached等,这些缓存方案实际上都是为了提升吞吐效率,避免持久层压力过大。

对于常见缓存类型而言,可以分为本地缓存以及分布式缓存两种,Caffeine就是一种优秀的本地缓存,而Redis可以用来做分布式缓存

2、Caffeine介绍

Caffeine官方:

  • https://github.com/ben-manes/caffeine

Caffeine是基于Java 1.8的高性能本地缓存库,由Guava改进而来,而且在Spring5开始的默认缓存实现就将Caffeine代替原来的Google Guava,官方说明指出,其缓存命中率已经接近最优值。实际上Caffeine这样的本地缓存和ConcurrentMap很像,即支持并发,并且支持O(1)时间复杂度的数据存取。二者的主要区别在于:

  • ConcurrentMap将存储所有存入的数据,直到你显式将其移除;

  • Caffeine将通过给定的配置,自动移除“不常用”的数据,以保持内存的合理占用。

因此,一种更好的理解方式是:Cache是一种带有存储和移除策略的Map。

8a5edc3e6edb1b07ec3eb04d67253ab6.png

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

二、Caffeine基础

使用Caffeine,需要在工程中引入如下依赖

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <!--https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeinez找最新版-->
    <version>3.0.5</version>
</dependency>
1、缓存加载策略
1.1 Cache手动创建

最普通的一种缓存,无需指定加载方式,需要手动调用put()进行加载。需要注意的是put()方法对于已存在的key将进行覆盖,这点和Map的表现是一致的。在获取缓存值时,如果想要在缓存值不存在时,原子地将值写入缓存,则可以调用get(key, k -> value)方法,该方法将避免写入竞争。调用invalidate()方法,将手动移除缓存。

在多线程情况下,当使用get(key, k -> value)时,如果有另一个线程同时调用本方法进行竞争,则后一线程会被阻塞,直到前一线程更新缓存完成;而若另一线程调用getIfPresent()方法,则会立即返回null,不会被阻塞。

Cache<Object, Object> cache = Caffeine.newBuilder()
          //初始数量
          .initialCapacity(10)
          //最大条数
          .maximumSize(10)
          //expireAfterWrite和expireAfterAccess同时存在时,以expireAfterWrite为准
          //最后一次写操作后经过指定时间过期
          .expireAfterWrite(1, TimeUnit.SECONDS)
          //最后一次读或写操作后经过指定时间过期
          .expireAfterAccess(1, TimeUnit.SECONDS)
          //监听缓存被移除
          .removalListener((key, val, removalCause) -> { })
          //记录命中
          .recordStats()
          .build();

  cache.put("1","张三");
  //张三
  System.out.println(cache.getIfPresent("1"));
  //存储的是默认值
  System.out.println(cache.get("2",o -> "默认值"));
1.2 Loading Cache自动创建

LoadingCache是一种自动加载的缓存。其和普通缓存不同的地方在于,当缓存不存在/缓存已过期时,若调用get()方法,则会自动调用CacheLoader.load()方法加载最新值。调用getAll()方法将遍历所有的key调用get(),除非实现了CacheLoader.loadAll()方法。使用LoadingCache时,需要指定CacheLoader,并实现其中的load()方法供缓存缺失时自动加载。

在多线程情况下,当两个线程同时调用get(),则后一线程将被阻塞,直至前一线程更新缓存完成。

LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
        //创建缓存或者最近一次更新缓存后经过指定时间间隔,刷新缓存;refreshAfterWrite仅支持LoadingCache
        .refreshAfterWrite(10, TimeUnit.SECONDS)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .expireAfterAccess(10, TimeUnit.SECONDS)
        .maximumSize(10)
        //根据key查询数据库里面的值,这里是个lamba表达式
        .build(key -> new Date().toString());
1.3 Async Cache异步获取

AsyncCache是Cache的一个变体,其响应结果均为CompletableFuture,通过这种方式,AsyncCache对异步编程模式进行了适配。默认情况下,缓存计算使用ForkJoinPool.commonPool()作为线程池,如果想要指定线程池,则可以覆盖并实现Caffeine.executor(Executor)方法。synchronous()提供了阻塞直到异步缓存生成完毕的能力,它将以Cache进行返回。

在多线程情况下,当两个线程同时调用get(key, k -> value),则会返回同一个CompletableFuture对象。由于返回结果本身不进行阻塞,可以根据业务设计自行选择阻塞等待或者非阻塞。

AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()
        //创建缓存或者最近一次更新缓存后经过指定时间间隔刷新缓存;仅支持LoadingCache
        .refreshAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterAccess(1, TimeUnit.SECONDS)
        .maximumSize(10)
        //根据key查询数据库里面的值
        .buildAsync(key -> {
            Thread.sleep(1000);
            return new Date().toString();
        });

//异步缓存返回的是CompletableFuture
CompletableFuture<String> future = asyncLoadingCache.get("1");
future.thenAccept(System.out::println);
2、驱逐策略

驱逐策略在创建缓存的时候进行指定。常用的有基于容量的驱逐和基于时间的驱逐。

基于容量的驱逐需要指定缓存容量的最大值,当缓存容量达到最大时,Caffeine将使用LRU策略对缓存进行淘汰;基于时间的驱逐策略如字面意思,可以设置在最后访问/写入一个缓存经过指定时间后,自动进行淘汰。

驱逐策略可以组合使用,任意驱逐策略生效后,该缓存条目即被驱逐。

  • LRU 最近最少使用,淘汰最长时间没有被使用的页面。

  • LFU 最不经常使用,淘汰一段时间内使用次数最少的页面

  • FIFO 先进先出

Caffeine有4种缓存淘汰设置

  • 大小 (LFU算法进行淘汰)

  • 权重 (大小与权重 只能二选一)

  • 时间

  • 引用 (不常用,本文不介绍)

@Slf4j
public class CacheTest {
    /**
     * 缓存大小淘汰
     */
    @Test
    public void maximumSizeTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                //超过10个后会使用W-TinyLFU算法进行淘汰
                .maximumSize(10)
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存:key:{} val:{}", key, val);
                })
                .build();

        for (int i = 1; i < 20; i++) {
            cache.put(i, i);
        }
        Thread.sleep(500);//缓存淘汰是异步的

        // 打印还没被淘汰的缓存
        System.out.println(cache.asMap());
    }

    /**
     * 权重淘汰
     */
    @Test
    public void maximumWeightTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                //限制总权重,若所有缓存的权重加起来>总权重就会淘汰权重小的缓存
                .maximumWeight(100)
                .weigher((Weigher<Integer, Integer>) (key, value) -> key)
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存:key:{} val:{}", key, val);
                })
                .build();

        //总权重其实是=所有缓存的权重加起来
        int maximumWeight = 0;
        for (int i = 1; i < 20; i++) {
            cache.put(i, i);
            maximumWeight += i;
        }
        System.out.println("总权重=" + maximumWeight);
        Thread.sleep(500);//缓存淘汰是异步的

        // 打印还没被淘汰的缓存
        System.out.println(cache.asMap());
    }


    /**
     * 访问后到期(每次访问都会重置时间,也就是说如果一直被访问就不会被淘汰)
     */
    @Test
    public void expireAfterAccessTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterAccess(1, TimeUnit.SECONDS)
                //可以指定调度程序来及时删除过期缓存项,而不是等待Caffeine触发定期维护
                //若不设置scheduler,则缓存会在下一次调用get的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存:key:{} val:{}", key, val);

                })
                .build();
        cache.put(1, 2);
        System.out.println(cache.getIfPresent(1));
        Thread.sleep(3000);
        System.out.println(cache.getIfPresent(1));//null
    }

    /**
     * 写入后到期
     */
    @Test
    public void expireAfterWriteTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.SECONDS)
                //可以指定调度程序来及时删除过期缓存项,而不是等待Caffeine触发定期维护
                //若不设置scheduler,则缓存会在下一次调用get的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存:key:{} val:{}", key, val);
                })
                .build();
        cache.put(1, 2);
        Thread.sleep(3000);
        System.out.println(cache.getIfPresent(1));//null
    }
}
3、刷新机制

refreshAfterWrite()表示x秒后自动刷新缓存的策略可以配合淘汰策略使用,注意的是刷新机制只支持LoadingCache和AsyncLoadingCache

private static int NUM = 0;

@Test
public void refreshAfterWriteTest() throws InterruptedException {
    LoadingCache<Integer, Integer> cache = Caffeine.newBuilder()
            .refreshAfterWrite(1, TimeUnit.SECONDS)
            //模拟获取数据,每次获取就自增1
            .build(integer -> ++NUM);

    //获取ID=1的值,由于缓存里还没有,所以会自动放入缓存
    System.out.println(cache.get(1));// 1

    // 延迟2秒后,理论上自动刷新缓存后取到的值是2
    // 但其实不是,值还是1,因为refreshAfterWrite并不是设置了n秒后重新获取就会自动刷新
    // 而是x秒后&&第二次调用getIfPresent的时候才会被动刷新
    Thread.sleep(2000);
    System.out.println(cache.getIfPresent(1));// 1

    //此时才会刷新缓存,而第一次拿到的还是旧值
    System.out.println(cache.getIfPresent(1));// 2
}
4、统计
LoadingCache<String, String> cache = Caffeine.newBuilder()
        //创建缓存或者最近一次更新缓存后经过指定时间间隔,刷新缓存;refreshAfterWrite仅支持LoadingCache
        .refreshAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterAccess(1, TimeUnit.SECONDS)
        .maximumSize(10)
        //开启记录缓存命中率等信息
        .recordStats()
        //根据key查询数据库里面的值
        .build(key -> {
            Thread.sleep(1000);
            return new Date().toString();
        });


cache.put("1", "shawn");
cache.get("1");

/*
 * hitCount :命中的次数
 * missCount:未命中次数
 * requestCount:请求次数
 * hitRate:命中率
 * missRate:丢失率
 * loadSuccessCount:成功加载新值的次数
 * loadExceptionCount:失败加载新值的次数
 * totalLoadCount:总条数
 * loadExceptionRate:失败加载新值的比率
 * totalLoadTime:全部加载时间
 * evictionCount:丢失的条数
 */
System.out.println(cache.stats());
5、总结

上述一些策略在创建时都可以进行自由组合,一般情况下有两种方法

  • 设置 maxSize、refreshAfterWrite,不设置 expireAfterWrite/expireAfterAccess,设置expireAfterWrite当缓存过期时会同步加锁获取缓存,所以设置expireAfterWrite时性能较好,但是某些时候会取旧数据,适合允许取到旧数据的场景

  • 设置 maxSize、expireAfterWrite/expireAfterAccess,不设置 refreshAfterWrite 数据一致性好,不会获取到旧数据,但是性能没那么好(对比起来),适合获取数据时不耗时的场景

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

三、SpringBoot整合Caffeine

1、@Cacheable相关注解
1.1 相关依赖

如果要使用@Cacheable注解,需要引入相关依赖,并在任一配置类文件上添加@EnableCaching注解

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
1.2 常用注解
  • @Cacheable :表示该方法支持缓存。当调用被注解的方法时,如果对应的键已经存在缓存,则不再执行方法体,而从缓存中直接返回。当方法返回null时,将不进行缓存操作。

  • @CachePut :表示执行该方法后,其值将作为最新结果更新到缓存中,每次都会执行该方法。

  • @CacheEvict :表示执行该方法后,将触发缓存清除操作。

  • @Caching :用于组合前三个注解,例如:

@Caching(cacheable = @Cacheable("CacheConstants.GET_USER"),
         evict = {@CacheEvict("CacheConstants.GET_DYNAMIC",allEntries = true)}
public User find(Integer id) {
    return null;
}
1.3 常用注解属性
  • cacheNames/value :缓存组件的名字,即cacheManager中缓存的名称。

  • key :缓存数据时使用的key。默认使用方法参数值,也可以使用SpEL表达式进行编写。

  • keyGenerator :和key二选一使用。

  • cacheManager :指定使用的缓存管理器。

  • condition :在方法执行开始前检查,在符合condition的情况下,进行缓存

  • unless :在方法执行完成后检查,在符合unless的情况下,不进行缓存

  • sync :是否使用同步模式。若使用同步模式,在多个线程同时对一个key进行load时,其他线程将被阻塞。

1.4 缓存同步模式

sync开启或关闭,在Cache和LoadingCache中的表现是不一致的:

  • Cache中,sync表示是否需要所有线程同步等待

  • LoadingCache中,sync表示在读取不存在/已驱逐的key时,是否执行被注解方法

2、实战
2.1 引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>
2.2 缓存常量CacheConstants

创建缓存常量类,把公共的常量提取一层,复用,这里也可以通过配置文件加载这些数据,例如@ConfigurationProperties和@Value

public class CacheConstants {
    /**
     * 默认过期时间(配置类中我使用的时间单位是秒,所以这里如 3*60 为3分钟)
     */
    public static final int DEFAULT_EXPIRES = 3 * 60;
    public static final int EXPIRES_5_MIN = 5 * 60;
    public static final int EXPIRES_10_MIN = 10 * 60;

    public static final String GET_USER = "GET:USER";
    public static final String GET_DYNAMIC = "GET:DYNAMIC";

}
2.3 缓存配置类CacheConfig
@Configuration
@EnableCaching
public class CacheConfig {
    /**
     * Caffeine配置说明:
     * initialCapacity=[integer]: 初始的缓存空间大小
     * maximumSize=[long]: 缓存的最大条数
     * maximumWeight=[long]: 缓存的最大权重
     * expireAfterAccess=[duration]: 最后一次写入或访问后经过固定时间过期
     * expireAfterWrite=[duration]: 最后一次写入后经过固定时间过期
     * refreshAfterWrite=[duration]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔,刷新缓存
     * weakKeys: 打开key的弱引用
     * weakValues:打开value的弱引用
     * softValues:打开value的软引用
     * recordStats:开发统计功能
     * 注意:
     * expireAfterWrite和expireAfterAccess同事存在时,以expireAfterWrite为准。
     * maximumSize和maximumWeight不可以同时使用
     * weakValues和softValues不可以同时使用
     */
    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        List<CaffeineCache> list = new ArrayList<>();
        //循环添加枚举类中自定义的缓存,可以自定义
        for (CacheEnum cacheEnum : CacheEnum.values()) {
            list.add(new CaffeineCache(cacheEnum.getName(),
                    Caffeine.newBuilder()
                            .initialCapacity(50)
                            .maximumSize(1000)
                            .expireAfterAccess(cacheEnum.getExpires(), TimeUnit.SECONDS)
                            .build()));
        }
        cacheManager.setCaches(list);
        return cacheManager;
    }
}
2.4 调用缓存

这里要注意的是Cache和@Transactional一样也使用了代理,类内调用将失效

/**
 * value:缓存key的前缀。
 * key:缓存key的后缀。
 * sync:设置如果缓存过期是不是只放一个请求去请求数据库,其他请求阻塞,默认是false(根据个人需求)。
 * unless:不缓存空值,这里不使用,会报错
 * 查询用户信息类
 * 如果需要加自定义字符串,需要用单引号
 * 如果查询为null,也会被缓存
 */
@Cacheable(value = CacheConstants.GET_USER,key = "'user'+#userId",sync = true)
@CacheEvict
public UserEntity getUserByUserId(Integer userId){
    UserEntity userEntity = userMapper.findById(userId);
    System.out.println("查询了数据库");
    return userEntity;
}


欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

3038379ed6507a4cd99f9486be4ea358.png

已在知识星球更新源码解析如下:

c553942cf35887687f00fb855d7007aa.jpeg

bc85bc314142aa05d3c30a21dae98e22.jpeg

28576f103eef1cd52df3b5a596a294b6.jpeg

c6c793b36a2517ce8c4f4f90898ef157.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 101 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
AD快速上手笔记 本文详细介绍了使用Altium Designer从零创建PCB项目全流程:新建工程、绘制原理图(元件放置、连线、电源端口)、编译检查、生成PCB、布局布线(含铺铜)、DRC检查及输出Gerber与钻孔文件。重点强调了库选择、参数修改、层切换、铺铜设置和生产文件导出规范,确保设计无误,便于顺利下单生产。 阅读详情

相关推荐

IAR9.30以上版本安装、注册、新建工程和配置过程详细介绍

IAR 一般是指一款嵌入式软件的集成开发环境,类似于 MDK-Keil 这款软件。IAR 对于不同的内核处理器,是对应不同的 IAR 软件的,IAR 到目前为止支持大部分的MCU,比如8051系列、ARM架构系列、MSP430系列、AVR系列等等这些常用的芯片架构。对于 ARM 架构的芯片,有对应的 IAR Embedded Workbench for ARM 软件平台,因为我主要是使用 ARM 架构芯片,下面安装、注册和使用都是基于这个版本进行介绍的。

luobeihai的博客 6万+

文章标题

Ehcache配置参数简介 2011-12-06 11:26:40| 分类: Hibernate |举报|字号 订阅 < defaultCache maxElementsInMemory = “10000” maxElementsOnDisk = “0” eternal = “true” overflowToDisk = “true”

liu5672934shuai的专栏 495

图像传感器与信号处理——SFR算法/ISO 12233解读

图像传感器与信号处理——SFR算法图像传感器与信号处理——SFR算法1. 前言2. 基于视觉的分辨率测量方法3. 基于边界的SFR算法4. 基于正弦波的SFR算法 图像传感器与信号处理——SFR算法 SFR的全称是Spatial Frequency Response,空间频率响应。介绍SFR算法的参考文献主要是ISO 12233这篇英文文档。和读一般的论文感觉不同,文档读起来更加晦涩难懂,可能是因...

weixin_44580210的博客 1万+

springboot+Redis+ehcache(双缓存)配置

1)maven和yml配置 maven配置如下: <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-ehcache</artifactId> <version>${hibernate.version}</...

zhoupan2008的专栏 1756

SAP SD POD 配置与 VLPOD 操作:3步解决发货10件开票7件的业务场景

本文详细解析了SAP SD POD功能在解决发货与开票数量差异中的应用,通过3步配置法实现精准匹配。重点介绍了POD核心逻辑、关键配置步骤及VLPOD操作技巧,帮助企业高效处理易损品运输等复杂场景,提升供应链管理效率。

weixin_30613343的博客 396

【突变检验合集】含Pettitt突变检验等

突变检验方法合集

WW、forever的博客 3535

ehcache配置

配置applicationContext.xml。配置ehcache.xml文件。引用ehcache包。

跟踪世界脚步 773

Python实现将txt文件转换成对应的excel或csv文件

此外,在上面的例子中,txt文件是以“空格”分隔的,如果遇到“逗号”分隔的,只需将上述代码中的。本文是该专栏的第29篇,后面会持续分享python的各种干货知识,值得关注。工作上可能会遇到这样的情况,使用python将某个txt文本,按照。转换成对应的excel文件或者是csv文件。”需要替换成你的目标txt文件的绝对路径。库,这里直接引用就好。需要注意的是,上述代码中的“

Python进阶专栏《爬虫实战进阶》,《Pyppeteer从入门到精通》原创作者 4506

EHCache 配置详解

  EHCache 是一个纯java 的在进程中的缓存, 它具有以下特性: 快速, 简单, 为Hibernate2.1 充当可插入的缓存, 最小的依赖性, 全面的文档和测试. 官方网站http://ehcache.sourceforge.net/ 毫 无疑问, 几乎所有的网站的首页都是访问率最高的, 而首页上的数据来源又是非常广泛的, 大多数来自不同的对象,...

TAINK 180

华为OD机试 - 第k个排列 - 全排列递归(Python/JS/C/C++ 2025 C卷 100分)

给定参数n,从1到n会有n个整数:1,2,3,…,n,这n个数字共有n!按大小顺序升序列出所有排列的情况,并一一标记当n=3时,所有排列如下“123”,“132,“213”,“231”,“312”,“321”输入两行,第一行为n,第二行为k,给定n的范围是[1,9],给定k的范围是[1,n!排列为“12”和“21”,第2个是“21”。给定n和k,返回第k个排列。输出排在第k位置的数字。只有一个排列,直接返回。

学Java,找哪吒 991

[明道云] -基础教学1- 创建第一个工作表:从 0 到实用

明道云工作表相当于数据库表,是存储业务数据的核心组件。创建工作表主要有两种方式:1)从空白新建,通过添加字段(最多200个)、设置属性、配置表单样式;2)从Excel导入,需选择sheet、配置字段映射。创建后系统自动生成默认视图,支持多种视图形式(看板/日历等)。建议设置合适的标题字段和关联关系,初学者可在一小时内完成基础应用搭建。后续可扩展权限控制、工作流自动化等功能。

每日出拳老爷子的博客 558

【Java】java | ruoyi-fast | ehcache改redis

留意ShrioConfig的filterChainDefinitionMap放行配置,会全部替换;系统之前的配置会被覆盖,比如:/h5/**,就丢了;1.替换类即可,不过命名需要改下;改造代码系统类为Sys开头,而fast没有Sys。改造前,代码打了git.tag,所以找回来了。

hgSuper的博客 940

采样率转化代码C++(有理倍数,升采样、降采样均可)

【代码】采样率转化(有理倍数,升采样、降采样均可)

goudahai的专栏 547

告别 Guava!再见 Ehcache!这才是 Java 本地缓存之王:Caffeine 完全解析

本文介绍了Java高性能本地缓存库Caffeine的核心优势和使用方法。Caffeine采用Window-TinyLFU算法实现近乎最优的命中率,通过无锁并发设计提供极致性能,相比Guava和Ehcache具有显著优势。文章详细解析了Caffeine的基础配置、多种淘汰策略、高级特性及监控统计功能,并提供了API响应缓存、数据库查询缓存等典型场景的实战案例。针对生产环境,文章还讨论了容量规划、性能调优、缓存一致性等关键问题,给出了从Guava/Ehcache迁移的指导方案。Caffeine已成为Java本地

油墨香^-^的博客 559

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

ehcache缓存原理_干掉GuavaCache:Caffeine才是本地缓存的王

话说,中间件的选择上,Spring(SpringBoot)一直是业界的风向标。比如Spring一直使用「Jackson」,而没有使用Gson和fastjson。SpringBoot2.0默认数据库连接池从TomcatPool换到了「HikariCP」。在本地缓存方面,SpringFramework5.0(SpringBoot2.0)放弃了Google的GuavaCache,选择了「Caffeine...

weixin_39683163的博客 206

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Java 本地缓存实现:Guava Cache、Caffeine、Ehcache 和 Spring Cache

Guava Cache 是 Google Guava 库的一部分,提供了轻量级的本地缓存功能。它具有以下特点:简单易用:API 设计简洁,易于集成到项目中。自动回收:支持基于时间或引用的自动回收机制。并发支持:内置高效的并发控制,适合多线程环境。Caffeine 是一个高性能的本地缓存库,继承了 Guava Cache 的优点并进行了优化。它的特点包括:高性能:比 Guava Cache 更快,特别是在高并发环境下。

勤于笔记,成于点滴。 1816

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

Java本地缓存技术选型(Guava Cache、Caffeine、EhCache)

对一个java开发者而言,提到缓存,第一反应就是Redis。利用这类缓存足以解决大多数的性能问题了,我们也要知道,这种属于remote cache(分布式缓存),应用的进程和缓存的进程通常分布在不同的服务器上,不同进程之间通过RPC或HTTP的方式通信。这种缓存的优点是缓存和应用服务解耦,支持大数据量的存储,缺点是数据要经过网络传输,性能上会有一定损耗。与分布式缓存对应的是本地缓存,缓存的进程和应用进程是同一个,数据的读写都在一个进程内完成,这种方式的优点是没有网络开销,访问速度很快。

程序员子龙 3339

【本地缓存】Java 中的 4 种本地缓存

是 Google 开发的 Guava 工具包中一套完善的JVM 本地缓存框架,底层实现的数据结构类似于,但是进行了更多的能力拓展,包括:缓存过期时间设置、缓存容量设置、多种淘汰策略、缓存监控等。是一个支持高并发的线程安全的本地缓存。多线程情况下也可以安全的访问或者更新 Cache,这些都是借鉴了的结果支持最大容量限制支持两种过期删除策略(插入时间和读取时间)支持简单的统计功能基于 LRU 算法实现Caffeine 官网Caffeine 是基于Java 1.8 的高性能本地缓存库。

sco5282的博客 1万+

再见,Guava!再见,Ehcache!

缓存(Cache)在代码世界中无处不在。从底层的CPU多级缓存,到客户端的页面缓存,处处都存在着缓存的身影。缓存从本质上来说,是一种空间换时间的手段,通过对数据进行一定的空间安排,使得下次进行数据访问时起到加速的效果。就Java而言,其常用的缓存解决方案有很多,例如数据库缓存框架EhCache,分布式缓存Memcached等,这些缓存方案实际上都是为了提升吞吐效率,避免持久层压力过大。

Java技术栈,分享最主流的Java技术 467

本地缓存组件Caffeine,与guava、map、ehcache对比

PS:Github Caffeine 介绍 Caffeine是一个基于Java8的高性能缓存库,提供了近乎最佳的命中率。 缓存与ConcurrentMap相似,但不完全相同。最根本的区别是ConcurrentMap将所有添加到其中的元素持久化,直到它们被显式删除。另一方面,缓存通常配置为自动逐出条目,以限制其内存占用。在某些情况下,如果缓存无法自动加载或逐出缓存项,则缓存加载会很有用。 Caffeine具有灵活的结构,可结合以下特点创建缓存: 自动将条目加载到缓存中,可以选择异步 基于频率和最.

进击的小白 5191

真实场景9:4大本地缓存(Map、Guava、Ehcache、Caffeine),选对了用好了,能让查询性能提升100倍

Ehcache 是用来管理缓存的一个工具,其缓存的数据可以是存放在内存里面的,也可以是存放在硬盘上的。优点是简单粗暴,不需要引入第三方包,比较适合一些比较简单的场景。然后呢,用户每天都会对我们的系统发起很多次复杂报表查询语句,但是这个 SQL 多表关联的一些逻辑,以及附加的一些查询条件几乎都是有规律的是差不多的,就是每天选择的当天日期是不太一样的。对于一些数据报表的复杂查询,其实每天的查询条件都是差不多的,只不过是当天的日期会有变化而已,另外就是对于一些数据报表的数据,往往是通过大数据平台进行离线计算的。

竹林幽深 2775

java指的本地缓存是指,Guava Cache、Ehcache、Caffeine这三个框架是什么,怎么使用

在Java中,"本地缓存"通常指的是在应用程序运行时使用的临时存储区域,用于存储和检索经常使用的数据,以提高性能和减少对远程资源的访问次数。本地缓存可以用于各种场景,如数据库查询结果、网络请求响应、计算结果等。本地缓存通常位于应用程序的内存中,因此访问速度非常快。它可以帮助减少对外部资源(如数据库、网络服务)的访问频率,从而提供更快的响应时间和较少的资源消耗。Java中的本地缓存可以通过多种方式实现,其中一种常见的方式是使用`HashMap`或`ConcurrentHashMap。

wanwanIT的博客 1252

java中ehcache 3.x和Guava cache的区别和联系,可以用代码实例说明

java中ehcache 3.x和Guava cache的区别和联系,可以用代码实例说明

gb4215287的博客 992

Java本地缓存

Java 中本地缓存通常指的是在应用程序内部通过数据结构(如 Map)或者专门的缓存库(比如 Ehcache、Guava Cache、Caffeine 等)实现的内存缓存,用于临时存储频繁访问的数据,以提高数据访问速度和降低对外部资源的依赖。提高数据访问速度:将频繁访问的数据存储在内存中,可以减少对外部资源(如数据库、远程服务)的访问,从而加快数据读取速度。减轻外部资源压力:通过缓存,可以减少对外部资源的请求次数,减轻外部资源的负载压力,提高系统整体的并发处理能力。

刘皇叔说Java的博客 3415

SpringBoot + EhCache实现本地缓存

一、EhCache 介绍 1.1 什么是EhCache ? EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认CacheProvider。Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储,缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。 Spring 提供了对缓存功能的抽象:即允许绑定不同的缓存解决方案(如Ehcache)

oyc的博客 2697

本地缓存Ehcache的应用实践 | 京东云技术团队

java本地缓存包含多个框架,其中常用的包括:Caffeine、Guava Cache和Ehcache, 其中Caffeine号称本地缓存之王,也是近年来被众多程序员推崇的缓存框架,同时也是SpringBoot内置的本地缓存实现。Ehcache的分布式实现并不可靠,核心还是采用广播集群方式,实现数据的同步及更新,并且性能受机器IO,磁盘,网络等影响,在实际应用情况下,不会比redis更好。**空闲时间:**缓存映射将在上次访问后的固定持续时间后过期;**生存周期:**缓存映射将在创建后的固定时间后过期;

京东科技开发者 1442
上一篇: 从华为跳槽到银行科技岗,好难!
下一篇: Redis分布式锁的10个坑
公众号-芋道源码
博客等级 码龄10年 1637粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值