13 秒插入 30 万条数据，这才是 Java 批量插入正确的姿势！

于 2024-05-01 19:46:35 发布
阅读量178 收藏 1
点赞数
文章标签： java 开发语言
原文链接：https://mp.weixin.qq.com/s?__biz=MzUxOTc4NjEyMw==&mid=2247578022&idx=3&sn=9df98b449481fedae7ee7afc098fff48&chksm=f8aad8d8b69fb1ee88fe65aa975cbddbd425eebb3ed9dbd24fe5e78de5424a2967bd7116c78b&scene=126&sessionid=0
版权

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料： 

effb9538514194490dd6d8bc1bf2a70b.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目，前端包括管理后台 + 微信小程序，后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号等等功能：

  • Boot 仓库：https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 仓库：https://gitee.com/zhijiantianya/yudao-cloud

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

【国内首批】支持 JDK 21 + SpringBoot 3.2.2、JDK 8 + Spring Boot 2.7.18 双版本 

来源：blog.csdn.net/qq_35427589
/article/details/129665307

d68623f8908aee14d5b7bccb15f5402a.jpeg

本文主要讲述通过MyBatis、JDBC等做大数据量数据插入的案例和结果。

30万条数据插入插入数据库验证

  • 实体类、mapper和配置文件定义

    • User实体

    • mapper接口

    • mapper.xml文件

    • jdbc.properties

    • sqlMapConfig.xml

  • 不分批次直接梭哈

  • 循环逐条插入

  • MyBatis实现插入30万条数据

  • JDBC实现插入30万条数据

  • 总结

验证的数据库表结构如下：

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `username` varchar(64) DEFAULT NULL COMMENT '用户名称',
  `age` int(4) DEFAULT NULL COMMENT '年龄',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户信息表';

话不多说，开整！

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

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

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

实体类、mapper和配置文件定义

User实体

/**
 * <p>用户实体</p>
 *
 * @Author zjq
 */
@Data
public class User {

    private int id;
    private String username;
    private int age;

}

mapper接口

public interface UserMapper {

    /**
     * 批量插入用户
     * @param userList
     */
    void batchInsertUser(@Param("list") List<User> userList);


}

mapper.xml文件

<!-- 批量插入用户信息 -->
<insert id="batchInsertUser" parameterType="java.util.List">
    insert into t_user(username,age) values
    <foreach collection="list" item="item" index="index" separator=",">
        (
        #{item.username},
        #{item.age}
        )
    </foreach>
</insert>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

sqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--通过properties标签加载外部properties文件-->
    <properties resource="jdbc.properties"></properties>


    <!--自定义别名-->
    <typeAliases>
        <typeAlias type="com.zjq.domain.User" alias="user"></typeAlias>
    </typeAliases>


    <!--数据源环境-->
    <environments default="developement">
        <environment id="developement">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>


    <!--加载映射文件-->
    <mappers>
        <mapper resource="com/zjq/mapper/UserMapper.xml"></mapper>
    </mappers>


</configuration>

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

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

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

不分批次直接梭哈

MyBatis直接一次性批量插入30万条，代码如下：

@Test
public void testBatchInsertUser() throws IOException {
    InputStream resourceAsStream =
            Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession session = sqlSessionFactory.openSession();
    System.out.println("===== 开始插入数据 =====");
    long startTime = System.currentTimeMillis();
    try {
        List<User> userList = new ArrayList<>();
        for (int i = 1; i <= 300000; i++) {
            User user = new User();
            user.setId(i);
            user.setUsername("共饮一杯无 " + i);
            user.setAge((int) (Math.random() * 100));
            userList.add(user);
        }
        session.insert("batchInsertUser", userList); // 最后插入剩余的数据
        session.commit();

        long spendTime = System.currentTimeMillis()-startTime;
        System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
    } finally {
        session.close();
    }
}

可以看到控制台输出：

Cause: com.mysql.jdbc.PacketTooBigException: Packet for query is too large (27759038 >yun 4194304). You can change this value on the server by setting the max_allowed_packet’ variable.

6ca0176c276c099d81e88cebf2dab25a.png

超出最大数据包限制了，可以通过调整max_allowed_packet限制来提高可以传输的内容，不过由于30万条数据超出太多，这个不可取，梭哈看来是不行了 😅😅😅

既然梭哈不行那我们就一条一条循环着插入行不行呢

循环逐条插入

mapper接口和mapper文件中新增单个用户新增的内容如下:

/**
 * 新增单个用户
 * @param user
 */
void insertUser(User user);
<!-- 新增用户信息 -->
<insert id="insertUser" parameterType="user">
    insert into t_user(username,age) values
        (
        #{username},
        #{age}
        )
</insert>

调整执行代码如下：

@Test
public void testCirculateInsertUser() throws IOException {
    InputStream resourceAsStream =
            Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession session = sqlSessionFactory.openSession();
    System.out.println("===== 开始插入数据 =====");
    long startTime = System.currentTimeMillis();
    try {
        for (int i = 1; i <= 300000; i++) {
            User user = new User();
            user.setId(i);
            user.setUsername("共饮一杯无 " + i);
            user.setAge((int) (Math.random() * 100));
            // 一条一条新增
            session.insert("insertUser", user);
            session.commit();
        }

        long spendTime = System.currentTimeMillis()-startTime;
        System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
    } finally {
        session.close();
    }
}

执行后可以发现磁盘IO占比飙升，一直处于高位。

066f9e6b5c5a692e2247ab320911af39.png

等啊等等啊等，好久还没执行完

8f6574d320e8031dc770da4c7e604907.gif

先不管他了太慢了先搞其他的，等会再来看看结果吧。

two thousand year later …

控制台输出如下：

69cb63e0624659cbcb20269fc9887f2e.png

总共执行了14909367毫秒，换算出来是4小时八分钟。太慢了。。

3b092dd8ed680ffcdb45a37be9d94a31.png

还是优化下之前的批处理方案吧

MyBatis实现插入30万条数据

先清理表数据，然后优化批处理执行插入：

-- 清空用户表
TRUNCATE table  t_user;

以下是通过 MyBatis 实现 30 万条数据插入代码实现：

/**
 * 分批次批量插入
 * @throws IOException
 */
@Test
public void testBatchInsertUser() throws IOException {
    InputStream resourceAsStream =
            Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession session = sqlSessionFactory.openSession();
    System.out.println("===== 开始插入数据 =====");
    long startTime = System.currentTimeMillis();
    int waitTime = 10;
    try {
        List<User> userList = new ArrayList<>();
        for (int i = 1; i <= 300000; i++) {
            User user = new User();
            user.setId(i);
            user.setUsername("共饮一杯无 " + i);
            user.setAge((int) (Math.random() * 100));
            userList.add(user);
            if (i % 1000 == 0) {
                session.insert("batchInsertUser", userList);
                // 每 1000 条数据提交一次事务
                session.commit();
                userList.clear();

                // 等待一段时间
                Thread.sleep(waitTime * 1000);
            }
        }
        // 最后插入剩余的数据
        if(!CollectionUtils.isEmpty(userList)) {
            session.insert("batchInsertUser", userList);
            session.commit();
        }

        long spendTime = System.currentTimeMillis()-startTime;
        System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        session.close();
    }
}

使用了 MyBatis 的批处理操作，将每 1000 条数据放在一个批次中插入，能够较为有效地提高插入速度。同时请注意在循环插入时要带有合适的等待时间和批处理大小，以防止出现内存占用过高等问题。此外，还需要在配置文件中设置合理的连接池和数据库的参数，以获得更好的性能。

342c51352083ca0f0acc12c2db988315.png

在上面的示例中，我们每插入1000行数据就进行一次批处理提交，并等待10秒钟。这有助于控制内存占用，并确保插入操作平稳进行。

4d872c9a15e2bb3d82544f83aa4473f0.png

五十分钟执行完毕，时间主要用在了等待上。

如果低谷时期执行，CPU和磁盘性能又足够的情况下，直接批处理不等待执行：

/**
 * 分批次批量插入
 * @throws IOException
 */
@Test
public void testBatchInsertUser() throws IOException {
    InputStream resourceAsStream =
            Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession session = sqlSessionFactory.openSession();
    System.out.println("===== 开始插入数据 =====");
    long startTime = System.currentTimeMillis();
    int waitTime = 10;
    try {
        List<User> userList = new ArrayList<>();
        for (int i = 1; i <= 300000; i++) {
            User user = new User();
            user.setId(i);
            user.setUsername("共饮一杯无 " + i);
            user.setAge((int) (Math.random() * 100));
            userList.add(user);
            if (i % 1000 == 0) {
                session.insert("batchInsertUser", userList);
                // 每 1000 条数据提交一次事务
                session.commit();
                userList.clear();
            }
        }
        // 最后插入剩余的数据
        if(!CollectionUtils.isEmpty(userList)) {
            session.insert("batchInsertUser", userList);
            session.commit();
        }

        long spendTime = System.currentTimeMillis()-startTime;
        System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        session.close();
    }
}

则24秒可以完成数据插入操作：

5ec404682567f1b75d3303df37993555.png 03f211edf5fea929846e46daaed24551.png

可以看到短时CPU和磁盘占用会飙高。

把批处理的量再调大一些调到5000，在执行：

eeceb1d5a513797a2945dafdcd1a4d8a.png

13秒插入成功30万条，直接芜湖起飞🛫🛫🛫

JDBC实现插入30万条数据

JDBC循环插入的话跟上面的mybatis逐条插入类似，不再赘述。

以下是 Java 使用 JDBC 批处理实现 30 万条数据插入的示例代码。请注意，该代码仅提供思路，具体实现需根据实际情况进行修改。

/**
 * JDBC分批次批量插入
 * @throws IOException
 */
@Test
public void testJDBCBatchInsertUser() throws IOException {
    Connection connection = null;
    PreparedStatement preparedStatement = null;

    String databaseURL = "jdbc:mysql://localhost:3306/test";
    String user = "root";
    String password = "root";

    try {
        connection = DriverManager.getConnection(databaseURL, user, password);
        // 关闭自动提交事务，改为手动提交
        connection.setAutoCommit(false);
        System.out.println("===== 开始插入数据 =====");
        long startTime = System.currentTimeMillis();
        String sqlInsert = "INSERT INTO t_user ( username, age) VALUES ( ?, ?)";
        preparedStatement = connection.prepareStatement(sqlInsert);

        Random random = new Random();
        for (int i = 1; i <= 300000; i++) {
            preparedStatement.setString(1, "共饮一杯无 " + i);
            preparedStatement.setInt(2, random.nextInt(100));
            // 添加到批处理中
            preparedStatement.addBatch();

            if (i % 1000 == 0) {
                // 每1000条数据提交一次
                preparedStatement.executeBatch();
                connection.commit();
                System.out.println("成功插入第 "+ i+" 条数据");
            }

        }
        // 处理剩余的数据
        preparedStatement.executeBatch();
        connection.commit();
        long spendTime = System.currentTimeMillis()-startTime;
        System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
    } catch (SQLException e) {
        System.out.println("Error: " + e.getMessage());
    } finally {
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}
880ec50fe02c04c7aff5215f4d638ea5.gif 471d7b6fd589a03e709704c1e17e883c.png

上述示例代码中，我们通过 JDBC 连接 MySQL 数据库，并执行批处理操作插入数据。具体实现步骤如下：

  • 获取数据库连接。

  • 创建 Statement 对象。

  • 定义 SQL 语句，使用 PreparedStatement 对象预编译 SQL 语句并设置参数。

  • 执行批处理操作。

  • 处理剩余的数据。

  • 关闭 Statement 和 Connection 对象。

使用setAutoCommit(false) 来禁止自动提交事务，然后在每次批量插入之后手动提交事务。每次插入数据时都新建一个 PreparedStatement 对象以避免状态不一致问题。在插入数据的循环中，每 10000 条数据就执行一次 executeBatch() 插入数据。

另外，需要根据实际情况优化连接池和数据库的相关配置，以防止连接超时等问题。

总结

实现高效的大量数据插入需要结合以下优化策略（建议综合使用）：

1.批处理： 批量提交SQL语句可以降低网络传输和处理开销，减少与数据库交互的次数。在Java中可以使用Statement或者PreparedStatement的addBatch()方法来添加多个SQL语句，然后一次性执行executeBatch()方法提交批处理的SQL语句。

  • 在循环插入时带有适当的等待时间和批处理大小，从而避免内存占用过高等问题：

    • 设置适当的批处理大小：批处理大小指在一次插入操作中插入多少行数据。如果批处理大小太小，插入操作的频率将很高，而如果批处理大小太大，可能会导致内存占用过高。通常，建议将批处理大小设置为1000-5000行，这将减少插入操作的频率并降低内存占用。

    • 采用适当的等待时间：等待时间指在批处理操作之间等待的时间量。等待时间过短可能会导致内存占用过高，而等待时间过长则可能会延迟插入操作的速度。通常，建议将等待时间设置为几秒钟到几十秒钟之间，这将使操作变得平滑且避免出现内存占用过高等问题。

    • 可以考虑使用一些内存优化的技巧，例如使用内存数据库或使用游标方式插入数据，以减少内存占用。

  • 总的来说，选择适当的批处理大小和等待时间可以帮助您平稳地进行插入操作，避免出现内存占用过高等问题。

2.索引: 在大量数据插入前暂时去掉索引，最后再打上，这样可以大大减少写入时候的更新索引的时间。

3.数据库连接池： 使用数据库连接池可以减少数据库连接建立和关闭的开销，提高性能。在没有使用数据库连接池的情况，记得在finally中关闭相关连接。

数据库参数调整：增加MySQL数据库缓冲区大小、配置高性能的磁盘和I/O等。

欢迎加入我的知识星球，全面提升技术能力。

👉 加入方式，“长按”或“扫描”下方二维码噢：

d7c5b4e848f318a420a93547a084234f.png

星球的内容包括：项目实战、面试招聘、源码解析、学习路线。

ed28364e6685eb97e49710f6d33ebbca.png

19a0aed8e5d7bdabe62f523f54c19382.png7f78b2574c75706c4ae40f8736b36334.png12c176474a3c3f236acfe21dc141cf0d.png05372332e68febdc6dfb354e977c2951.png

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）
Java基基
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java快速插入千万级数据
05-25
java快速插入千万级数据，亲测91秒插入1700万数据！！！
Mybatis高效批量插入实战：五种策略全面解析
最新发布
wenxuankeji的博客
05-10 481
Mybatis高效批量插入实战：五种策略全面解析
java实现批量插入数据代码示例
mischen520的博客
11-15 671
在实际开发中，经常需要批量插入数据，常见的是使用mybatis foreach 插入的方式，1.常见的mybatis foreach。2.类似的mapper方法。3.业务层代码，数据组装。
Java怎么实现几十万条同时数据插入（三种基本方法测试）
weixin_46504244的博客
04-12 4077
在Java中实现插入几十万条数据，有多种方法可以使用。
java实现批量插入
weixin_44258947的博客
12-06 3913
//业务背景：在实现一次性插入上万条数据时会报错，所有要批量插入 public void addCouponCode(List<CouponCodeEntity> lists){ if (CollectionUtils.isEmpty(lists)) { return; } int numPerTimes = 200; if (lists.size() <= numPerTimes) { batchAdd(list
java 批量插入千万条数据优化方案【值得收藏】
javaXingzhe的博客
03-01 7915
java 千万条数据插入mysql优化
88秒插入1000万条数据到MySQL数据库表的操作方法
09-09
在本教程中，我们将探讨如何在88秒内将1000万条数据高效地插入到MySQL数据库表中，使用的数据库版本为5.7。首先，遇到的问题是`PacketTooBigException`，这是由于单个数据包大小超过了MySQL服务器允许的最大值（默认...
Java使用JDBC向MySQL数据库批次插入10W条数据(测试效率)
08-31
综上所述，Java使用JDBC进行批量插入数据是通过PreparedStatement的批处理功能实现的，通过设置手动提交和优化连接字符串，以及合理控制批量处理的大小和选择合适的数据库配置，可以有效地提高插入10万条或更多数据...
java中JDBC实现往MySQL插入百万级数据的实例代码
08-31
在Java开发中，当需要处理大量数据插入到MySQL数据库时，传统的逐条插入方式效率低下，可能导致长时间的等待。为了提高性能，可以采用JDBC的批量处理（Batch Processing）功能。下面将详细介绍如何使用JDBC批量操作...
Java面试题75：批量插入几百万条数据.mp4
09-09
Java面试题75：批量插入几百万条数据.mp4
sql下三种批量插入数据的方法
12-15
本文将介绍三种批量插入数据的方法。第一种方法是使用循环语句逐个将数据项插入到数据库中；第二种方法使用的是SqlBulkCopy，使您可以用其他源的数据有效批量加载 SQL Server 表；第三种使用的方法是sql server中的...
Java怎么实现几十万条数据插入(30万条数据插入MySQL仅需13秒)转载非原创
m0_59849460的博客
03-23 1867
使用了 MyBatis 的批处理操作，将每 1000 条数据放在一个批次中插入，能够较为有效地提高插入速度。同时请注意在循环插入时要带有合适的等待时间和批处理大小，以防止出现内存占用过高等问题。限制来提高可以传输的内容，不过由于30万条数据超出太多，这个不可取，梭哈看来是不行了 😅😅😅。总共执行了14909367毫秒，换算出来是4小时八分钟。超出最大数据包限制了，可以通过调整。执行后可以发现磁盘IO占比飙升，一直处于高位。springboot项目直接一次性。和数据库的参数，以获得更好的性能。
MyBatis 批量插入-优化&效率对比
常有理爱摸鱼
10-08 4177
今天我们围绕Mybatis批量插入的for循环插入、batch()伪批量插入、真实批量插入-方法、真实批量插入-配置的效率&优劣进行详解。
Java批量更新插入太慢？list分段+多线程处理
zhyang_2021的博客
07-01 2606
当需要插入或修改大量数据时，我们会选择mybatis的批处理，但是这存在一些弊端针对以上问题，拆分list和多线程处理，会很好解决。
Java8 实现批量插入和更新，SpringBoot实现批量插入和更新，Mybatis实现批量插入和更新
weixin_43992507的博客
08-18 2275
Java 实现批量插入和更新，SpringBoot实现批量插入和更新，Mybatis实现批量插入和更新
批量插入
博客的博客
03-28 4508
目录 一、批量插入数据 ⚪JDBC的批量处理语句的方法 二、高效的批量插入 1.举例：向goods表中插入20000条数据 ⭐goods表的创建 方式一：使用Statement 方式二：使用PreparedStatement替换Statement 🌙方式一与方式二的对比 方式三： 相关方法的调用 方式四： 设置连接不允许自动提交数据 一、批量插入数据 PreparedStatement可以实现更高效的批量操作 update、delete本身就具有批量操作的效果 此时的批量操.
mysql插10万条数据_MySQL插入10万数据时间（结论：最快14.967s，每秒插入6681条）...
weixin_39520199的博客
12-20 1821
记录我的一次MySQL操作Demo：存储过程：DROP PROCEDURE IF EXISTSmy_insert;CREATE PROCEDUREmy_insert()BEGINDECLARE n int DEFAULT 1;loopname:LOOPINSERT INTO user_info(id,name,age,gender,address,tel)VALUES(n,'lilis',16,2...
Java怎么实现几十万条数据插入(30万条数据插入MySQL仅需13秒)
热门推荐
write less , do more
03-20 7万+
Java怎么实现几十万条数据插入(30万条数据插入仅需13秒)
java 多线程数据库插入千万级数据
06-03
在 Java 中实现多线程数据库插入千万级数据，可以采用线程池的方式来实现。 首先，创建一个线程池，然后将数据分割成若干个数据块，每个线程处理一个数据块，将数据插入到数据库中。在插入数据时，可以采用批处理的方式，将多条数据一次性插入到数据库中，以提高效率。 下面是一个简单的示例代码，用于实现多线程数据库插入千万级数据： ```java import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class MultiThreadInsert { private static final String url = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC"; private static final String user = "root"; private static final String password = "root"; public static void main(String[] args) { int threadNum = 10; // 线程数 int dataSize = 10000000; // 数据量 int batchSize = 1000; // 批处理大小 // 数据块大小 int blockSize = dataSize / threadNum; if (blockSize % batchSize != 0) { blockSize = (blockSize / batchSize + 1) * batchSize; } // 生成数据 List<List<String>> dataList = generateData(dataSize); // 线程池 ExecutorService executor = Executors.newFixedThreadPool(threadNum); // 数据库连接 Connection conn = null; try { conn = DriverManager.getConnection(url, user, password); // 插入数据 for (int i = 0; i < threadNum; i++) { int start = i * blockSize; int end = start + blockSize; if (end > dataSize) { end = dataSize; } List<List<String>> subList = dataList.subList(start, end); executor.execute(new InsertTask(subList, conn, batchSize)); } // 关闭线程池 executor.shutdown(); while (!executor.isTerminated()) { Thread.sleep(100); } System.out.println("数据插入完成！"); } catch (SQLException | InterruptedException e) { e.printStackTrace(); } finally { if (conn != null) { try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } } // 生成数据 private static List<List<String>> generateData(int dataSize) { List<List<String>> dataList = new ArrayList<>(); for (int i = 0; i < dataSize; i++) { List<String> row = new ArrayList<>(); row.add("value1"); row.add("value2"); row.add("value3"); dataList.add(row); } return dataList; } } // 插入数据任务 class InsertTask implements Runnable { private List<List<String>> dataList; private Connection conn; private int batchSize; public InsertTask(List<List<String>> dataList, Connection conn, int batchSize) { this.dataList = dataList; this.conn = conn; this.batchSize = batchSize; } @Override public void run() { try { String sql = "INSERT INTO test_table (column1, column2, column3) VALUES (?, ?, ?)"; PreparedStatement ps = conn.prepareStatement(sql); int count = 0; for (List<String> row : dataList) { ps.setString(1, row.get(0)); ps.setString(2, row.get(1)); ps.setString(3, row.get(2)); ps.addBatch(); count++; if (count % batchSize == 0) { ps.executeBatch(); count = 0; } } if (count > 0) { ps.executeBatch(); } ps.close(); } catch (SQLException e) { e.printStackTrace(); } } } ``` 在上面的示例代码中，我们使用了线程池来创建多个线程，将数据分割成若干个数据块，每个线程处理一个数据块，将数据插入到数据库中。同时，我们还使用了批处理的方式，将多条数据一次性插入到数据库中，以提高效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值