SpringBoot整合Caffeine

news2024/9/25 13:19:28



一、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。

图片

基于 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;
}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/833080.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

java：解决报错非法字符: ‘\ufeff‘以及什么是BOM

java：解决报错非法字符: ‘\ufeff‘以及什么是BOM

背景 运行 JAVA 项目后&#xff0c;报错提示&#xff1a;非法字符: \ufeff&#xff0c;如图&#xff1a; 但是我在这个报错的文件中并没有搜到这个字符&#xff0c;那到底是什么原因 什么是BOM BOM&#xff08;Byte Order Mark&#xff09;&#xff0c;隐藏字符&#xff0c…
阅读更多...
5、二叉树

5、二叉树

二叉树遍历 递归序 public static void f(Node head) {if (head == null) {return;}f(head.left);f(head.right); }前中后遍历_递归 public static void preOrderRecur(Node head) {if (head == null) {return;}System.out.print(head.value + " ");preOrderRecur…
阅读更多...
智慧防汛，数字科技的力量

智慧防汛，数字科技的力量

随着夏日的脚步临近&#xff0c;台风季节即将降临。对于那些居住在沿海地区的人们来说&#xff0c;台风是一种常见的自然灾害&#xff0c;其带来的风雨可能对生命和财产造成严重威胁。然而&#xff0c;随着数字科技的飞速发展&#xff0c;可视化技术为防汛抗台工作带来了全新的…
阅读更多...
6个非常实用的漫画素材网站，设计师必看

6个非常实用的漫画素材网站，设计师必看

对于漫画设计师来说&#xff0c;漫画素材网站是必不可少的&#xff0c;今天本文将与大家分享6个好用的漫画素材网站&#xff0c;帮助设计师实现优质创作&#xff0c;一起来看看吧&#xff01; 1、即时设计 即时设计是更适合国内设计师使用的图像设计工具&#xff0c;在它的【…
阅读更多...
if语句实现成绩等级判断

if语句实现成绩等级判断

if语句实现成绩等级判断 案例分析代码实现小结Time 案例分析 使用键盘输入一个成绩&#xff0c;然后通过if判断语句实现成绩等级的判断 代码实现 import java.util.Scanner;public class DetermineDemo {public static void main(String[] args) {Scanner scanner new Scanne…
阅读更多...
在线五子棋对战

在线五子棋对战

目录 数据管理模块&#xff08;数据库设计&#xff09; 前端界面模块 业务处理模块 会话管理模块网络通信模块(session,cookie) 在线管理模块 房间管理模块 用户匹配模块 项目扩展 数据管理模块&#xff08;数据库设计&#xff09; 数据库中有可能存在很多张表&#xf…
阅读更多...
SystemC的调度器

SystemC的调度器

文章目录 前言调度器初始化evaluatewait updatenotify delta notificationtime notification仿真结束 前言 SystemC是基于C的库&#xff0c;主要用来对 IC 进行功能建模和性能建模。有时也被用来当做 RTL (register transfer level) 级的升级版 HLS(High Level synthesis) 直接…
阅读更多...
Hadoop-HDFS的Namenode及Datanode（参考Hadoop官网）

Hadoop-HDFS的Namenode及Datanode（参考Hadoop官网）

HDFS有什么特点&#xff0c;被设计做什么 Hadoop分布式文件系统(HDFS)被设计成适合运行在通用硬件(commodity hardware)上的分布式文件系统。有一下几个特点&#xff1a; HDFS是一个高度容错性的系统&#xff0c;具有高容错、高可靠性、高扩展性的特点&#xff0c;适合部…
阅读更多...
【卡尔曼滤波】用Python实现卡尔曼滤波效果，Python

【卡尔曼滤波】用Python实现卡尔曼滤波效果，Python

文章目录 纯python基于pykalman 库 纯python 以下是一个简单的Python示例&#xff0c;演示了如何使用NumPy库实现一个一维卡尔曼滤波器。 import numpy as np import matplotlib.pyplot as pltdef kalman_filter(initial_state, initial_estimate_error, process_variance, me…
阅读更多...
机器学习笔记 - 使用 YOLOv5、O​​penCV、Python 和 C++ 检测物体

机器学习笔记 - 使用 YOLOv5、O​​penCV、Python 和 C++ 检测物体

一、YOLO v5简述 YOLO v5虽然已经不是最先进的对象检测器，但是YOLOv5 使用了一个简单的卷积神经网络 CNN架构（相对YOLO v8来讲，不过v8精度是更高了一些），更易理解。这里主要介绍如何轻松使用 YOLO v5来识别图像中的对象。将使用 OpenCV、Python 和 C++ 来加载和调用我们的…
阅读更多...
Cadence 小技巧系列（持续更新）

Cadence 小技巧系列（持续更新）

■ ADE setup simulator/directory/host 更改仿真路径&#xff0c;默认home路径空间太小了&#xff0c;改成当前路径就行。 瞬态tran仿真要用APS跑&#xff08;setup--high...&#xff09; 瞬态tran仿真精度设置&#xff0c;conservation&#xff0c;option--maxstep设为0.1n…
阅读更多...
Android 13(T) - Media框架（2）- libmedia

Android 13(T) - Media框架（2）- libmedia

这一节学习有两个目标&#xff1a; 1 熟悉Android Media API的源码路径与调用层次 2 从MediaPlayer的创建与销毁了解与native的串接 1、源码路径 Media相关的API位于&#xff1a;frameworks/base/media/java/android/media&#xff0c;里面提供有MediaPlayer MediaCodecList M…
阅读更多...
Java判断Object类型的方法

Java判断Object类型的方法

Java判断Object类型的方法 private boolean check(Object obj) {if(obj.getClass()java.util.Date.class){return true;}else {return false;}}
阅读更多...
GPU版PyTorch对应安装教程

GPU版PyTorch对应安装教程

一、正确安装符合自己电脑的对应GPU版本的PyTorch之前需要了解三个基本概念 算力、CUDA driver version、CUDA runtime version ①算力&#xff1a;需要先知道你的显卡&#xff0c;之后根据官网表格进行对应&#xff0c;得到算力 ②CUDA driver version&#xff1a;电脑上显卡…
阅读更多...
RISC-V基础之函数调用（二）栈与寄存器（包含实例）

RISC-V基础之函数调用（二）栈与寄存器（包含实例）

堆栈是一种后进先出&#xff08;LIFO&#xff09;的队列&#xff0c;用于存储函数调用时的临时数据和现场数据。堆栈指针sp&#xff08;寄存器2&#xff09;是一个普通的RISC-V寄存器&#xff0c;按照惯例&#xff0c;指向堆栈的顶部。堆栈从高地址向低地址增长&#xff0c;即当…
阅读更多...
设置系统编码 Beta

设置系统编码 Beta

在yolov5环境搭建过程中会遇到如下的编码错误警告&#xff1a; 这时&#xff0c;按住“ctrlc”中止进程&#xff0c;然后设置系统编码&#xff1a; 电脑右键属性打开&#xff1a; 重启之后等安装好了&#xff0c;记得回去把bae键取消。
阅读更多...
人工智能发展的五个主要技术方向是什么？

人工智能发展的五个主要技术方向是什么？

人工智能主要分支介绍 通讯、感知与行动是现代人工智能的三个关键能力&#xff0c;在这里我们将根据这些能力/应用对这三个技术领域进行介绍&#xff1a; 计算机视觉(CV) 自然语言处理(NLP) 在 NLP 领域中&#xff0c;将覆盖文本挖掘/分类、机器翻译和语音识别。 机器人 1、…
阅读更多...
linux鲁班猫屏幕和触摸[初用鲁班猫切换屏幕为MIPI-1080P][旋转屏幕为横屏显示][屏幕和触摸方向永久修改]

linux鲁班猫屏幕和触摸[初用鲁班猫切换屏幕为MIPI-1080P][旋转屏幕为横屏显示][屏幕和触摸方向永久修改]

初用鲁班猫切换屏幕为MIPI-1080P 鲁班猫信息: 板卡从如下地址采购:https://detail.tmall.com/item.htm?_u110jcean66aa&id694560455663&spma1z09.2.0.0.56f52e8dj4eUdI&skuId5156903694777 鲁班猫官方文档和教程:https://doc.embedfire.com/linux/rk356x/quick_s…
阅读更多...
[Docker实现测试部署CI/CD----自由风格的CI操作[中间架构]（4）]

[Docker实现测试部署CI/CD----自由风格的CI操作[中间架构]（4）]

10、自由风格的CI操作&#xff08;中间架构&#xff09; 中间架构图 创建web项目 创建一个 web 项目&#xff0c;就使用简单的 spring boot 工程&#xff0c;例如工程名为 hellojks。仅需导 入 spring web 依赖即可。 import org.springframework.web.bind.annotation.GetMapp…
阅读更多...
Android性能优化—内存优化

Android性能优化—内存优化

一、App内存组成以及管理 Android 给每个 App 分配一个 VM &#xff0c;让App运行在 dalvik 上&#xff0c;这样即使 App 崩溃也不会影响到系统。系统给 VM 分配了一定的内存大小&#xff0c; App 可以申请使用的内存大小不能超过此硬性逻辑限制&#xff0c;就算物理内存富余&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023