0
0

【文件增量备份系统】MySQL百万量级数据量分页查询性能优化

🎯 导读：本文针对大数据量下的分页查询性能问题进行了深入探讨与优化，最初查询耗时长达12秒，通过避免全表计数及利用缓存保存总数的方式显著提升了浅分页查询速度。面对深分页时依然存在的延迟，采用先查询倒数第N条记录ID，再依据此ID获取后继记录的策略，进一步降低了查询时间。此方案适用于优化大量数据背景下的分页展示性能问题。
🏠️ 项目仓库：数据增量备份系统
📙 项目介绍：【文件增量备份系统】系统功能介绍与开源说明

文章目录

问题说明

当数据量达到百万级时，查询性能已经非常慢了

在这里插入图片描述
经过查看日志，可以发现查询一次接口，耗时高达 两年半 5 秒，而且查的还是第一页，等查完数据，黄花菜都凉了，受不了一点，为了用户的体验，必须改进

原因排查

原始代码如下，对id进行降序排序是因为id是递增的，id越大，代表文件备份时间越新。对id进行排序是为了把最新备份的文件记录放在最前面

  1. @OverridepublicPageResponse<BackupFile>pageBackupFileV1(BackupFileRequest request,boolean isOrder){long start =System.currentTimeMillis();QueryWrapper<BackupFile> queryWrapper =newQueryWrapper<>();if(request.getBackupSourceId()!=null){
  2.         queryWrapper.eq("backup_source_id", request.getBackupSourceId());}if(request.getBackupTargetId()!=null){
  3.         queryWrapper.eq("backup_target_id", request.getBackupTargetId());}if(!StringUtils.isEmpty(request.getSourceFilePath())){
  4.         queryWrapper.like("source_file_path", request.getSourceFilePath());}if(!StringUtils.isEmpty(request.getTargetFilePath())){
  5.         queryWrapper.like("target_file_path", request.getTargetFilePath());}
  6.     queryWrapper.orderByDesc("id");IPage<BackupFile> page = baseMapper.selectPage(newPage(request.getCurrent(), request.getSize()), queryWrapper);System.out.println("分页查询时间："+(System.currentTimeMillis()- start)+"ms");returnPageUtil.convert(page);}

在这里插入图片描述

通过查看日志，发现在一次分页查询中，主要做两件事情：

  • 查询数据总条数
  1. SELECTCOUNT(*)AS total FROM backup_file
  • 进行真正的分页查询
  1. SELECT id,backup_source_id,backup_target_id,source_file_path,target_file_path,backup_num,file_type,last_backup_time,file_name,file_suffix,file_length,file_length_after_compress,father_id,is_compress,is_contain_file,create_time,update_time FROM backup_file ORDERBY id DESCLIMIT10

那上面慢的是哪个sql呢，还是说两个都慢，分别对两个sql进行单元测试

【查询数据总条数】

  1. ==>  Preparing: SELECTCOUNT(*)AS total FROM backup_file
  2. ==> Parameters:
  3. <==Columns: total
  4. <==Row: 3458533<==      Total: 1
  5. Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@521d455c]
  6. 时间：4093ms

【进行真正的分页查询】

  1. ==>  Preparing: SELECT id,backup_source_id,backup_target_id,source_file_path,target_file_path,backup_num,file_type,last_backup_time,file_name,file_suffix,file_length,file_length_after_compress,father_id,is_compress,is_contain_file,create_time,update_time FROM backup_file ORDERBY id DESCLIMIT10==> Parameters:
  2. <==Columns: id, backup_source_id, backup_target_id, source_file_path, target_file_path, backup_num, file_type, last_backup_time, file_name, file_suffix, file_length, file_length_after_compress, father_id, is_compress, is_contain_file, create_time, update_time
  3. ......<==      Total: 10
  4. Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@327ac23]
  5. 时间：25ms

好家伙，原来慢的是查询总数。那为什么这么慢呢？
原因是 COUNT() 需要遍历整个表中的每一行来计算总行数（涉及大量的磁盘I/O操作，尤其是如果数据分布在多个磁盘块上时），因为行数多，所以慢

total查询优化

既然查询total那么久的话，怎么加速total查询呢，最方便的一个方法就是使用缓存。查询一次total就把它放到缓存中，当新增或修改数据时，再更新缓存

实现步骤

在缓存类中添加一个原子类的备份文件总数属性

  1. importjava.util.Set;importjava.util.concurrent.ConcurrentHashMap;importjava.util.concurrent.atomic.AtomicLong;/**
  2.  * 缓存类
  3.  *
  4.  * @Author dam
  5.  * @create 2024/2/19 19:57
  6.  */publicclassCache{....../**
  7.      * 所备份文件的总数量
  8.      */publicstaticAtomicLong FILE_TOTAL_NUM =newAtomicLong();}

实现一个更新缓存值的方法

  1. /**
  2.  * 更新缓存中的total值
  3.  */@OverridepublicvoidupdateTotalCache(){Long total = baseMapper.selectCount(newQueryWrapper<BackupFile>().select("id"));
  4.     FILE_TOTAL_NUM.set(total);}

在项目启动成功之后，调用上面方法记录total值

  1. importlombok.extern.slf4j.Slf4j;importorg.dam.service.BackupFileService;importorg.dam.service.BackupTaskService;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.boot.CommandLineRunner;importorg.springframework.stereotype.Component;/**
  2.  * @Author dam
  3.  * @create 2024/1/25 19:29
  4.  */@Component@Slf4jpublicclassBackupTaskInitimplementsCommandLineRunner{@AutowiredprivateBackupTaskService backupTaskService;@AutowiredprivateBackupFileService backupFileService;@Overridepublicvoidrun(String... args)throwsException{
  5.         log.info("项目启动成功，执行初始化，将没有完成的备份任务设置为失败状态");
  6.         backupTaskService.updateNotFinishedTask();
  8.         log.info("项目启动成功，更新备份文件总数缓存");
  9.         backupFileService.updateTotalCache();}}

修改分页查询方法：在分页查询的时候，不要查询总数，总数从缓存中读取

  1. @OverridepublicPageResponse<BackupFile>pageBackupFileV2(BackupFileRequest request,boolean isOrder){long start =System.currentTimeMillis();QueryWrapper<BackupFile> queryWrapper =newQueryWrapper<>();if(request.getBackupSourceId()!=null){
  2.         queryWrapper.eq("backup_source_id", request.getBackupSourceId());}if(request.getBackupTargetId()!=null){
  3.         queryWrapper.eq("backup_target_id", request.getBackupTargetId());}if(!StringUtils.isEmpty(request.getSourceFilePath())){
  4.         queryWrapper.like("source_file_path", request.getSourceFilePath());}if(!StringUtils.isEmpty(request.getTargetFilePath())){
  5.         queryWrapper.like("target_file_path", request.getTargetFilePath());}
  6.     queryWrapper.orderByDesc("id");Page<BackupFile> page =newPage<>(request.getCurrent(), request.getSize());// 关闭总记录数统计
  7.     page.setSearchCount(false);IPage<BackupFile> pageResult = baseMapper.selectPage(page, queryWrapper);List<BackupFile> backupFileList = pageResult.getRecords();PageResponse pageResponse =newPageResponse();
  8.     pageResponse.setRecords(backupFileList);
  9.     pageResponse.setCurrent(request.getCurrent());
  10.     pageResponse.setSize(request.getSize());
  11.     pageResponse.setTotal(Cache.FILE_TOTAL_NUM.get());System.out.println("分页查询时间："+(System.currentTimeMillis()- start)+"ms");return pageResponse;}

新增文件、删除文件时更新缓存值

由于该系统仅为个人使用，对缓存的时效性要求没有那么高，因此我只在备份结束的时候更新缓存值即可

  1. /**
  2.  * 根据备份任务来进行备份
  3.  *
  4.  * @param task                备份任务
  5.  * @param ignoreFileList      忽略文件名列表
  6.  * @param ignoreDirectoryList 忽略目录名列表
  7.  */privatevoidbackUpByTask(Task task,List<String> ignoreFileList,List<String> ignoreDirectoryList)throwsIOException{......// 更新备份文件总数缓存
  8.     backupFileService.updateTotalCache();}

测试

查询第一页数据仅需要17ms，性能得到了飞一般的提升

在这里插入图片描述

你以为到这里就优化完了吗？不不不，随着分页的深度逐步加深，查询的速度会越来越慢，请继续阅读下面的深分页问题

深分页问题优化

问题说明

在这里插入图片描述
当查看最后一页数据时（数据量有3,459,110条），发现耗时竟然接近 8 秒，性能还是太差了。原因：我们默认的分页是使用offset来实现的，假设有10000条数据，当我们查询最后一页时，即使我们只需要10条数据，数据库也需要先检索出前面的99990条记录并丢弃它们，才能得到我们需要的结果，所以这个过程很慢

  1. ==>  Preparing: SELECT id,backup_source_id,backup_target_id,source_file_path,target_file_path,backup_num,file_type,last_backup_time,file_name,file_suffix,file_length,file_length_after_compress,father_id,is_compress,is_contain_file,create_time,update_time FROM backup_file ORDERBY id DESCLIMIT ? OFFSET ?
  2. ==> Parameters: 10(Long),3459100(Long)......<==      Total: 10
  3. Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3fc32129]
  4. 分页查询时间：7712ms

优化实现

首先根据偏移量查询id

  1. <select id="selectIDByOffset" resultType="java.lang.Long">select id
  2.     from backup_file
  3.     orderby id desclimit#{offset}, 1</select>

再根据查询到的 id 来取后面 size 条数据

  1. // 将所有sql包裹在一个事务中执行，避免创建两次SqlSession。设置为只读事务，因为这里没有更新操作@Transactional(readOnly =true)@OverridepublicPageResponse<BackupFile>pageBackupFileV3(BackupFileRequest request,boolean isOrder){long start =System.currentTimeMillis();
  2.     request.setOffset((request.getCurrent()-1)* request.getSize());Long idByOffset = baseMapper.selectIDByOffset((request.getCurrent()-1)* request.getSize());QueryWrapper<BackupFile> queryWrapper =newQueryWrapper<>();if(request.getBackupSourceId()!=null){
  3.         queryWrapper.eq("backup_source_id", request.getBackupSourceId());}if(request.getBackupTargetId()!=null){
  4.         queryWrapper.eq("backup_target_id", request.getBackupTargetId());}if(!StringUtils.isEmpty(request.getSourceFilePath())){
  5.         queryWrapper.like("source_file_path", request.getSourceFilePath());}if(!StringUtils.isEmpty(request.getTargetFilePath())){
  6.         queryWrapper.like("target_file_path", request.getTargetFilePath());}
  7.     queryWrapper.orderByDesc("id");
  8.     queryWrapper.le("id", idByOffset);
  9.     queryWrapper.last("LIMIT "+ request.getSize());List<BackupFile> backupFileList = baseMapper.selectList(queryWrapper);PageResponse pageResponse =newPageResponse();
  10.     pageResponse.setRecords(backupFileList);
  11.     pageResponse.setCurrent(request.getCurrent());
  12.     pageResponse.setSize(request.getSize());
  13.     pageResponse.setTotal(Cache.FILE_TOTAL_NUM.get());System.out.println("分页查询时间："+(System.currentTimeMillis()- start)+"ms");return pageResponse;}

有读者可能有疑问。为什么要分两次查询，不直接用一个子查询sql来实现呢？（例如下面的代码）我测试了，发现浅分页的时候，查询的结果没有问题，深分页之后，查出来的数据和直接分页查询的数据对不上，不知道是不是我用了分表，对子查询产生了影响（有知道的大佬求求在评论区教教我，非常感谢）

  1. select f1.id,
  2.        f1.backup_source_id,
  3.        f1.backup_target_id,
  4.        f1.source_file_path,
  5.        f1.target_file_path,
  6.        f1.backup_num,
  7.        f1.file_type,
  8.        f1.last_backup_time,
  9.        f1.file_name,
  10.        f1.file_suffix,
  11.        f1.file_length,
  12.        f1.file_length_after_compress,
  13.        f1.father_id,
  14.        f1.is_compress,
  15.        f1.is_contain_file,
  16.        f1.create_time,
  17.        f1.update_time
  18. from backup_file f1
  19. where(select id
  20.        from backup_file
  21.        orderby id desclimit#{request.offset} , 1) >= idorderby f1.id desclimit#{request.size}

测试

经过测试，发现最后一页的查询时间为 3.4 s，又把时间减少了一半

  1. Creating a new SqlSession
  2. Registering transaction synchronization for SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4cbb45b9]
  3. JDBC Connection [HikariProxyConnection@1178808009 wrapping org.apache.shardingsphere.driver.jdbc.core.connection.ShardingSphereConnection@2c08fcbd] will be managed by Spring
  4. ==>  Preparing: select id from backup_file orderby id desclimit ?,1==> Parameters: 3459100(Long)<==Columns: id
  5. <==Row: 1760179379180195842<==      Total: 1
  6. Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4cbb45b9]
  7. Fetched SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4cbb45b9]fromcurrenttransaction==>  Preparing: SELECT id,backup_source_id,backup_target_id,source_file_path,target_file_path,backup_num,file_type,last_backup_time,file_name,file_suffix,file_length,file_length_after_compress,father_id,is_compress,is_contain_file,create_time,update_time FROM backup_file WHERE(id <= ?)ORDERBY id DESCLIMIT10==> Parameters: 1760179379180195842(Long).....
  8. Releasing transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4cbb45b9]
  9. 分页查询时间：3492ms
  10. Transaction synchronization committing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4cbb45b9]Transaction synchronization deregistering SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4cbb45b9]Transaction synchronization closing SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4cbb45b9]

explain效率比较分析

通过单元测试，发现时间主要花费在根据偏移量查询id，后面根据偏移 id 来查询数据就很快了。

  1. ==> Parameters:
  2. <==Columns: id
  3. <==Row: 1760179379180195842<==      Total: 1
  4. Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@46b4d4e7]
  5. id：1760179379180195842
  6. 查id时间：3169ms
  8. Creating a new SqlSession
  9. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3387d45e] was not registered for synchronization because synchronization isnot active
  10. JDBC Connection [HikariProxyConnection@1063860793 wrapping org.apache.shardingsphere.driver.jdbc.core.connection.ShardingSphereConnection@1ef7e4c7] will not be managed by Spring
  11. ==>  Preparing: select id, backup_source_id, backup_target_id, source_file_path, target_file_path, backup_num, file_type, last_backup_time, file_name, file_suffix, file_length, file_length_after_compress, father_id, is_compress, is_contain_file, create_time, update_time from backup_file where ? >= id orderby id desclimit10==> Parameters: 1760179379180195842(Long)......
  12. Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3387d45e]
  13. 查数据时间：27ms

【直接分页查询】

  1. explainSELECT id,backup_source_id,backup_target_id,source_file_path,target_file_path,backup_num,file_type,last_backup_time,file_name,file_suffix,file_length,file_length_after_compress,father_id,is_compress,is_contain_file,create_time,update_time FROM backup_file_5 ORDERBY id DESCLIMIT1000,10

在这里插入图片描述

  • 查询类型（type）为"index"，这意味着MySQL正在执行全索引扫描。这通常意味着查询只访问索引树上的数据，而不需要回表获取其他列的信息。
  • possible_keys 列显示为空，表示没有指定任何可能使用的键。然而，key 列显示 PRIMARY，说明实际上使用了主键作为索引。
  • key_len 列值为8，表明在主键上使用了完整的索引长度。对于一个整数类型的主键来说，这通常是正确的。
  • ref 列显示为 NULL，这是因为在这个查询中没有涉及与其他表的关联操作。
  • rows 列显示预计需要读取的行数为10,010。这表明查询将遍历大约10,010个索引项来找到满足条件的数据。
  • Extra 列显示 “Backward index scan”，表示MySQL正在进行反向索引扫描。这通常发生在查询从高到低排序时，或者当查询优化器认为这样做更有效率时。

【根据偏移量查询id】

  1. explainselect id from backup_file_5 orderby id desclimit1000,1

在这里插入图片描述
从分析来看，很多指标和【直接分页查询】是一样的，区别是extra值为"Backward index scan; Using index" 表明正在进行反向索引扫描，并且只使用索引，无需回表查询原始数据

【根据偏移 id 来查询数据】

  1. explainselect id, backup_source_id, backup_target_id, source_file_path, target_file_path, backup_num, file_type, last_backup_time, file_name, file_suffix, file_length, file_length_after_compress, father_id, is_compress, is_contain_file, create_time, update_time from backup_file_5 where7373278992159211536>= id orderby id desclimit10

在这里插入图片描述

  • 查询类型（type）为"range"，这意味着MySQL正在执行范围扫描。比全表扫描或全索引扫描要好
  • possible_keys 列显示为空，表示没有指定任何可能使用的键
  • key 列显示 PRIMARY，说明实际上使用了主键作为索引
  • key_len 列值为8，表明在主键上使用了完整的索引长度。对于一个整数类型的主键来说，这通常是正确的
  • ref 列显示为 NULL，这是因为在这个查询中没有涉及与其他表的关联操作
  • rows 列显示预计需要读取的行数为124。这表明查询将遍历大约124个索引项来找到满足条件的数据
  • Extra 列显示 “Using where; Backward index scan”，表示MySQL正在进行反向索引扫描，并应用了WHERE子句中的条件

【总结】

  • 根据偏移量查询id：相对于直接分页查询，只使用 id 来查询，数据量更小，且无需回表操作查询其他字段，消耗的时间和资源少
  • 根据偏移 id 来查询数据：只需要范围扫描，效率更高

总结

  • 查询效率有了比较大的提升 - 查询第一页，查询时间从5秒下降到ms级别，性能有巨大提升- 查询最后一页数据，直接分页查询耗时12.5 秒，改进查询下降到3.4 s，性能提升 3.6 倍
  • 随着数据量的进一步提升，达到千万级，现在的实现方案在查询深分页时性能肯定会非常差，还需要进一步的优化。
  • 其他常用的效率优化逻辑 - 冷热数据分离：将不常使用的数据迁移到其他数据库中- 使用游标分页：记录上一页的最后一条数据id，这样查下一页就很快了，缺点是只能上下页，无法随意切换页
标签： 性能优化 MySQL 深分页优化
本文转载自: https://blog.csdn.net/laodanqiu/article/details/142550476
版权归原作者 Hello Dam 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【文件增量备份系统】MySQL百万量级数据量分页查询性能优化”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？