首页 > 数据库 >面试官：1亿条数据批量插入 MySQL，哪种方式最快？

面试官：1亿条数据批量插入 MySQL，哪种方式最快？

时间：2022-09-25 23:33:38浏览次数：88  
标签：面试官 1W 耗时 事务 插入 MySQL 数据 10W 亿条

这几天研究mysql优化中查询效率时，发现测试的数据太少（10万级别），利用 EXPLAIN 比较不同的 SQL 语句，不能够得到比较有效的测评数据，大多模棱两可，不敢通过这些数据下定论。

所以通过随机生成人的姓名、年龄、性别、电话、email、地址 ，向mysql数据库大量插入数据，便于用大量的数据测试 SQL 语句优化效率。、在生成过程中发现使用不同的方法，效率天差万别。

1、先上Mysql数据库，随机生成的人员数据图。分别是ID、姓名、性别、年龄、Email、电话、住址。

下图一共三千三百万数据：

在数据量在亿级别时，别点下面按钮，会导致Navicat持续加载这亿级别的数据，导致电脑死机。~觉着自己电脑配置不错的可以去试试，可能会有惊喜

 

2、本次测评一共通过三种策略，五种情况，进行大批量数据插入测试

策略分别是：

  • Mybatis 轻量级框架插入（无事务）

  • 采用JDBC直接处理（开启事务、无事务）

  • 采用JDBC批处理（开启事务、无事务）

测试结果：

Mybatis轻量级插入 -> JDBC直接处理 -> JDBC 批处理。

JDBC 批处理，效率最高

第一种策略测试：

2.1 Mybatis 轻量级框架插入（无事务）

Mybatis是一个轻量级框架，它比hibernate轻便、效率高。

但是处理大批量的数据插入操作时，需要过程中实现一个ORM的转换，本次测试存在实例，以及未开启事务，导致mybatis效率很一般。

这里实验内容是：

  • 利用Spring框架生成mapper实例、创建人物实例对象

  • 循环更改该实例对象属性、并插入。

  1. //代码内无事务
  2.  
  3.  private long begin = 33112001;//起始id
  4.     private long end = begin+100000;//每次循环插入的数据量
  5.     private String url = "jdbc:mysql://localhost:3306/bigdata?useServerPrepStmts=false&rewriteBatchedStatements=true&useUnicode=true&characterEncoding=UTF-8";
  6.     private String user = "root";
  7.     private String password = "0203";
  8.     
  9.     
  10. @org.junit.Test
  11.     public void insertBigData2()
  12.     {
  13.         //加载Spring，以及得到PersonMapper实例对象。这里创建的时间并不对最后结果产生很大的影响
  14.         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  15.         PersonMapper pMapper = (PersonMapper) context.getBean("personMapper");
  16.         //创建一个人实例
  17.         Person person = new Person();
  18.         //计开始时间
  19.         long bTime = System.currentTimeMillis();
  20.         //开始循环，循环次数500W次。
  21.         for(int i=0;i<5000000;i++)
  22.         {
  23.             //为person赋值
  24.             person.setId(i);
  25.             person.setName(RandomValue.getChineseName());
  26.             person.setSex(RandomValue.name_sex);
  27.             person.setAge(RandomValue.getNum(1, 100));
  28.             person.setEmail(RandomValue.getEmail(4,15));
  29.             person.setTel(RandomValue.getTel());
  30.             person.setAddress(RandomValue.getRoad());
  31.             //执行插入语句
  32.             pMapper.insert(person);
  33.             begin++;
  34.         }
  35.         //计结束时间
  36.         long eTime = System.currentTimeMillis();
  37.         System.out.println("插入500W条数据耗时："+(eTime-bTime));
  38.     }

本想测试插入五百万条数据，但是实际运行过程中太慢，中途不得不终止程序。最后得到52W数据，大约耗时两首歌的时间（7~9分钟）。随后，利用mybatis向mysql插入10000数据。

结果如下：

利用mybatis插入 一万 条数据耗时：28613，即28.6秒

第二种策略测试：

2.2 采用JDBC直接处理（开启事务、关闭事务）

采用JDBC直接处理的策略，这里的实验内容分为开启事务、未开启事务是两种，过程均如下：

  • 利用PreparedStatment预编译

  • 循环，插入对应数据，并存入

事务对于插入数据有多大的影响呢？看下面的实验结果:

  1. //该代码为开启事务
  2.  private long begin = 33112001;//起始id
  3.     private long end = begin+100000;//每次循环插入的数据量
  4.     private String url = "jdbc:mysql://localhost:3306/bigdata?useServerPrepStmts=false&rewriteBatchedStatements=true&useUnicode=true&amp;characterEncoding=UTF-8";
  5.     private String user = "root";
  6.     private String password = "0203";
  7.  
  8.  
  9. @org.junit.Test
  10.     public void insertBigData3() {
  11.         //定义连接、statement对象
  12.         Connection conn = null;
  13.         PreparedStatement pstm = null;
  14.         try {
  15.             //加载jdbc驱动
  16.             Class.forName("com.mysql.jdbc.Driver");
  17.             //连接mysql
  18.             conn = DriverManager.getConnection(url, user, password);
  19.              //将自动提交关闭
  20.              conn.setAutoCommit(false);
  21.             //编写sql
  22.             String sql = "INSERT INTO person VALUES (?,?,?,?,?,?,?)";
  23.             //预编译sql
  24.             pstm = conn.prepareStatement(sql);
  25.             //开始总计时
  26.             long bTime1 = System.currentTimeMillis();
  27.             
  28.             //循环10次，每次一万数据，一共10万
  29.             for(int i=0;i<10;i++) {
  30.                 //开启分段计时，计1W数据耗时
  31.                 long bTime = System.currentTimeMillis();
  32.                 //开始循环
  33.                 while (begin < end) {
  34.                     //赋值
  35.                     pstm.setLong(1, begin);
  36.                     pstm.setString(2, RandomValue.getChineseName());
  37.                     pstm.setString(3, RandomValue.name_sex);
  38.                     pstm.setInt(4, RandomValue.getNum(1, 100));
  39.                     pstm.setString(5, RandomValue.getEmail(4, 15));
  40.                     pstm.setString(6, RandomValue.getTel());
  41.                     pstm.setString(7, RandomValue.getRoad());
  42.                     //执行sql
  43.                     pstm.execute();
  44.                     begin++;
  45.                 }
  46.                 //提交事务
  47.                 conn.commit();
  48.                 //边界值自增10W
  49.                 end += 10000;
  50.                 //关闭分段计时
  51.                 long eTime = System.currentTimeMillis();
  52.                 //输出
  53.                 System.out.println("成功插入1W条数据耗时："+(eTime-bTime));
  54.             }
  55.             //关闭总计时
  56.             long eTime1 = System.currentTimeMillis();
  57.             //输出
  58.             System.out.println("插入10W数据共耗时："+(eTime1-bTime1));
  59.         } catch (SQLException e) {
  60.             e.printStackTrace();
  61.         } catch (ClassNotFoundException e1) {
  62.             e1.printStackTrace();
  63.         }
  64.     }

1、我们首先利用上述代码测试无事务状态下，插入10W条数据需要耗时多少。

如图：

 

  1. 成功插入1W条数据耗时：21603
  2. 成功插入1W条数据耗时：20537
  3. 成功插入1W条数据耗时：20470
  4. 成功插入1W条数据耗时：21160
  5. 成功插入1W条数据耗时：23270
  6. 成功插入1W条数据耗时：21230
  7. 成功插入1W条数据耗时：20372
  8. 成功插入1W条数据耗时：22608
  9. 成功插入1W条数据耗时：20361
  10. 成功插入1W条数据耗时：20494
  11. 插入10W数据共耗时：212106

实验结论如下：

在未开启事务的情况下，平均每 21.2 秒插入 一万 数据。

接着我们测试开启事务后，插入十万条数据耗时，如图：

  1. 成功插入1W条数据耗时：4938
  2. 成功插入1W条数据耗时：3518
  3. 成功插入1W条数据耗时：3713
  4. 成功插入1W条数据耗时：3883
  5. 成功插入1W条数据耗时：3872
  6. 成功插入1W条数据耗时：3873
  7. 成功插入1W条数据耗时：3863
  8. 成功插入1W条数据耗时：3819
  9. 成功插入1W条数据耗时：3933
  10. 成功插入1W条数据耗时：3811
  11. 插入10W数据共耗时：39255

实验结论如下：

开启事务后，平均每 3.9 秒插入 一万 数据

第三种策略测试：

2.3 采用JDBC批处理（开启事务、无事务）

采用JDBC批处理时需要注意一下几点：

1、在URL连接时需要开启批处理、以及预编译

  1. String url = “jdbc:mysql://localhost:3306/User?rewriteBatched
  2. -Statements=true&useServerPrepStmts=false”;

2、PreparedStatement预处理sql语句必须放在循环体外

代码如下：

  1. private long begin = 33112001;//起始id
  2. private long end = begin+100000;//每次循环插入的数据量
  3. private String url = "jdbc:mysql://localhost:3306/bigdata?useServerPrepStmts=false&rewriteBatchedStatements=true&useUnicode=true&amp;characterEncoding=UTF-8";
  4. private String user = "root";
  5. private String password = "0203";
  6.  
  7.  
  8. @org.junit.Test
  9. public void insertBigData() {
  10.     //定义连接、statement对象
  11.     Connection conn = null;
  12.     PreparedStatement pstm = null;
  13.     try {
  14.         //加载jdbc驱动
  15.         Class.forName("com.mysql.jdbc.Driver");
  16.         //连接mysql
  17.         conn = DriverManager.getConnection(url, user, password);
  18.   //将自动提交关闭
  19.   // conn.setAutoCommit(false);
  20.         //编写sql
  21.         String sql = "INSERT INTO person VALUES (?,?,?,?,?,?,?)";
  22.         //预编译sql
  23.         pstm = conn.prepareStatement(sql);
  24.         //开始总计时
  25.         long bTime1 = System.currentTimeMillis();
  26.  
  27.         //循环10次，每次十万数据，一共1000万
  28.         for(int i=0;i<10;i++) {
  29.  
  30.             //开启分段计时，计1W数据耗时
  31.             long bTime = System.currentTimeMillis();
  32.             //开始循环
  33.             while (begin < end) {
  34.                 //赋值
  35.                 pstm.setLong(1, begin);
  36.                 pstm.setString(2, RandomValue.getChineseName());
  37.                 pstm.setString(3, RandomValue.name_sex);
  38.                 pstm.setInt(4, RandomValue.getNum(1, 100));
  39.                 pstm.setString(5, RandomValue.getEmail(4, 15));
  40.                 pstm.setString(6, RandomValue.getTel());
  41.                 pstm.setString(7, RandomValue.getRoad());
  42.                 //添加到同一个批处理中
  43.                 pstm.addBatch();
  44.                 begin++;
  45.             }
  46.             //执行批处理
  47.             pstm.executeBatch();
  48.            //提交事务
  49.   //        conn.commit();
  50.             //边界值自增10W
  51.             end += 100000;
  52.             //关闭分段计时
  53.             long eTime = System.currentTimeMillis();
  54.             //输出
  55.             System.out.println("成功插入10W条数据耗时："+(eTime-bTime));
  56.         }
  57.         //关闭总计时
  58.         long eTime1 = System.currentTimeMillis();
  59.         //输出
  60.         System.out.println("插入100W数据共耗时："+(eTime1-bTime1));
  61.     } catch (SQLException e) {
  62.         e.printStackTrace();
  63.     } catch (ClassNotFoundException e1) {
  64.         e1.printStackTrace();
  65.     }
  66. }

首先开始测试

无事务，每次循环插入10W条数据，循环10次，一共100W条数据。

结果如下图：

  1. 成功插入10W条数据耗时：3832
  2. 成功插入10W条数据耗时：1770
  3. 成功插入10W条数据耗时：2628
  4. 成功插入10W条数据耗时：2140
  5. 成功插入10W条数据耗时：2148
  6. 成功插入10W条数据耗时：1757
  7. 成功插入10W条数据耗时：1767
  8. 成功插入10W条数据耗时：1832
  9. 成功插入10W条数据耗时：1830
  10. 成功插入10W条数据耗时：2031
  11. 插入100W数据共耗时：21737

实验结果：

使用JDBC批处理，未开启事务下，平均每 2.1 秒插入 十万 条数据

接着测试

开启事务，每次循环插入10W条数据，循环10次，一共100W条数据。

结果如下图：

 

  1. 成功插入10W条数据耗时：3482
  2. 成功插入10W条数据耗时：1776
  3. 成功插入10W条数据耗时：1979
  4. 成功插入10W条数据耗时：1730
  5. 成功插入10W条数据耗时：1643
  6. 成功插入10W条数据耗时：1665
  7. 成功插入10W条数据耗时：1622
  8. 成功插入10W条数据耗时：1624
  9. 成功插入10W条数据耗时：1779
  10. 成功插入10W条数据耗时：1698
  11. 插入100W数据共耗时：19003

实验结果：

使用JDBC批处理，开启事务，平均每 1.9 秒插入 十万 条数据

3 总结

能够看到，在开启事务下 JDBC直接处理 和 JDBC批处理 均耗时更短。

  • Mybatis 轻量级框架插入 , mybatis在我这次实验被黑的可惨了，哈哈。实际开启事务以后，差距不会这么大（差距10倍）。大家有兴趣的可以接着去测试

  • JDBC直接处理，在本次实验，开启事务和关闭事务，耗时差距5倍左右，并且这个倍数会随着数据量的增大而增大。因为在未开启事务时，更新10000条数据，就得访问数据库10000次。导致每次操作都需要操作一次数据库。

  • JDBC批处理，在本次实验，开启事务与关闭事务，耗时差距很微小（后面会增加测试，加大这个数值的差距）。但是能够看到开启事务以后，速度还是有提升。

结论：设计到大量单条数据的插入，使用JDBC批处理和事务混合速度最快

实测使用批处理+事务混合插入1亿条数据耗时：174756毫秒

4 补充

JDBC批处理事务，开启和关闭事务，测评插入20次，一次50W数据，一共一千万数据耗时：

1、开启事务(数据太长不全贴了)

插入1000W数据共耗时：197654

2、关闭事务(数据太长不全贴了)

插入1000W数据共耗时：200540

还是没很大的差距~

借用：

分别是：

  • 不用批处理，不用事务；

  • 只用批处理，不用事务；

  • 只用事务，不用批处理；

  • 既用事务，也用批处理；（很明显，这个最快，所以建议在处理大批量的数据时，同时使用批处理和事务）

 敬请期待我的下一篇文章，谢谢。

更多java进阶资料，面试资料，关注公众号

来源：https://blog.csdn.net/qq_19007169/article/details/124835249

标签：面试官,1W,耗时,事务,插入,MySQL,数据,10W,亿条
From： https://www.cnblogs.com/konglxblog/p/16729383.html

相关文章

  • MySQL常用知识点梳理
    删表DROPTABLEIFEXISTS表名；新建表createtable表名(字段名类型约束（逐渐，非空，唯一，默认值），字段名类型约束（逐渐，非空，唯一，默认值），)编码，存储引擎；约束N......
  • 2022-09-25-近60道MySQL经典面试题
    近60道MySQL经典面试题mysql面试常见问题学习整理2.3.17.18.19.20.44未看。1.B树和B+树之间的区别是？为什么mysql使用B+树？一个节点有多个元素；B+树也是排序了的；B+树非叶......
  • MySQL的join算法优化
    在Mysql的实现中，Nested-LoopJoin有3种实现的算法：SimpleNested-LoopJoin：SNLJ，简单嵌套循环连接IndexNested-LoopJoin：INLJ，索引嵌套循环连接BlockNested-LoopJoin：BN......
  • MySQL 的一条语句的执行流程
    分为客户端，服务端，存储引擎三部分。mysql8.0后，取消缓存。1.myisam和innodb的区别。Mysql的InnoDB和MyISAM存储引擎的常见区别如下：锁支持：MyISAM只有表级锁(table-lev......
  • mysql存储引擎
    MySQL存储引擎概述MySQL5.0支持的存储引擎包括MyISAM、InnoDB、BDB、MEMORY、MERGE、EXAMPLE、NDBCluster、ARCHIVE、CSV、BLACKHOLE、FEDERATED等，其中Inno......
  • mysql整理
    mysql整理跨库更新数据UPDATEpmcc_assess.tb_project_infoaTableINNERJOIN(SELECTidasdata_id,uuidasdata_uuidFROMpmcc_contract.tb_cms_contractbTa......
  • mysql函数
    日期函数返回当前日期，只包含年月日selectcurdate()返回当前时间，只包含时分秒selectcurtime()返回当前的日期和时间，年月日时分秒全都包含selectnow()提取......
  • mysql_数据库设计三范式
    设计关系数据库时，遵从不同的规范要求，设计出合理的关系型数据库，这些不同的规范要求被称为不同的范式，各种范式呈递次规范，越高的范式数据库冗余越小。目前关系数据库有六......
  • mysql事务
    什么是事务一系列有序的数据库操作：要么全部成功要么全部回退到操作前的状态中间状态对其他连接不可见事务的基本操作：|基本操作|说明||:-------------|:-......
  • mysql 数据库设计的规范
    数据库设计的规范数据库表和字段都大写表都要加业务后缀，例如_C客户表_B基础表_P权限表必须有主键，主键是表名去掉业务后缀，加_ID，大多表的主键使用UUID字段多个单词时，......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99