java上亿条数据循环新增怎么处理

原创

mob64ca12d16caa 2025-02-15 03:39:57 ©著作权

文章标签 数据 java sql 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mob64ca12d16caa的原创作品，请联系作者获取转载授权，否则将追究法律责任

在处理Java中上亿条数据的循环新增时，面临的挑战主要包括性能优化、内存管理、事务处理等。本文将详细探讨如何有效地解决这些问题，并提供相应的代码示例，帮助开发者更好地理解和实现数据新增操作。

问题分析

在面对上亿条数据时，直接使用单线程循环逐条插入数据会导致性能下降。我们需要使用以下策略进行优化：

批量处理：将多条记录合并为一次数据库操作。
多线程处理：充分利用CPU资源，加快数据插入的速度。
数据流处理：利用流处理架构，以减少内存使用和提高数据处理效率。
数据库连接池：避免频繁创建和销毁数据库连接，提升性能。

解决方案

1. 批量插入

首先，使用批量插入是提高插入速度的一种有效方式。以JDBC为例，我们可以使用addBatch和executeBatch方法。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class BatchInsertExample {
    private static final String URL = "jdbc:mysql://localhost:3306/your_database";
    private static final String USER = "your_username";
    private static final String PASSWORD = "your_password";

    public static void main(String[] args) {
        String insertSQL = "INSERT INTO your_table (column1, column2) VALUES (?, ?)";
        
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement preparedStatement = connection.prepareStatement(insertSQL)) {

            connection.setAutoCommit(false); // 关闭自动提交

            for (int i = 1; i <= 1000000; i++) {
                preparedStatement.setString(1, "Data " + i);
                preparedStatement.setInt(2, i);

                preparedStatement.addBatch(); // 添加到批处理中

                if (i % 1000 == 0) { // 每1000条提交一次
                    preparedStatement.executeBatch();
                    connection.commit(); // 提交事务
                }
            }
            preparedStatement.executeBatch(); // 提交剩余数据
            connection.commit(); // 再次提交事务
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

2. 多线程插入

使用多线程则可以进一步提升插入性能。Java中的ExecutorService可以用来管理线程池，进行并发插入。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadedInsert {
    private static final String URL = "jdbc:mysql://localhost:3306/your_database";
    private static final String USER = "your_username";
    private static final String PASSWORD = "your_password";
    
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10); // 10个线程

        for (int i = 0; i < 10; i++) {
            final int batchNumber = i;

            executorService.submit(() -> {
                String insertSQL = "INSERT INTO your_table (column1, column2) VALUES (?, ?)";
                try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
                     PreparedStatement preparedStatement = connection.prepareStatement(insertSQL)) {
                     
                    connection.setAutoCommit(false);
                    for (int j = batchNumber * 100000; j < (batchNumber + 1) * 100000; j++) {
                        preparedStatement.setString(1, "Data " + j);
                        preparedStatement.setInt(2, j);
                        preparedStatement.addBatch();

                        if (j % 1000 == 0) {
                            preparedStatement.executeBatch();
                            connection.commit();
                        }
                    }
                    preparedStatement.executeBatch();
                    connection.commit();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            });
        }
        
        executorService.shutdown(); // 关闭线程池
    }
}

3. 数据流处理

通过数据流处理，我们可以避免一次性加载所有数据，进而减少内存使用。利用Stream API可以帮助我们处理大量数据。

import java.util.stream.IntStream;

public class StreamInsertExample {
    public static void main(String[] args) {
        IntStream.range(0, 1000000).parallel().forEach(i -> {
            // 在这里执行插入逻辑
        });
    }
}

状态图

在我的解决方案中，整个处理流程可以表示为以下状态图：

stateDiagram
    [*] --> Start
    Start --> BatchInsertion
    BatchInsertion --> Commit
    Commit --> MultiThreading
    MultiThreading --> StreamProcessing
    StreamProcessing --> [*]