大量数据情况下单线程插入和多线程insert数据库的性能测试

大量数据情况下单线程插入和多线程insert数据库的性能测试

 

之前一直没有遇到过大批量数据入库的场景,所以一直没有思考过在大量数据的情况下单线程插入和多线程插入的性能情况。今天在看一个项目源代码的时候发现使用了多线程insert操作。

于是简单的写了一个测试程序来测试一批数据在N个线程下的insert情况。

public class ThreadImport {
    private String url="jdbc:oracle:thin:@localhost:1521:orcl";
    private String user="cmis";
    private String password="cmis";
    public Connection getConnect(){
        Connection con = null;
         try {
            Class.forName("oracle.jdbc.driver.OracleDriver");
            con=DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
         return con;
    }
    public void multiThreadImport( final int ThreadNum){
        final CountDownLatch cdl= new CountDownLatch(ThreadNum);
        long starttime=System.currentTimeMillis();
        for(int k=1;k<=ThreadNum;k++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Connection con=getConnect();
                    try {
                        Statement st=con.createStatement();
                        for(int i=1;i<=80000/ThreadNum;i++){
                            String uuid=UUID.randomUUID().toString();
                            st.addBatch("insert into demo_table(a,b) values('"+uuid+"','"+uuid+"')");
                            if(i%500==0){
                                st.executeBatch();
                            }
                        }
                        cdl.countDown();
                    } catch (Exception e) {
                    }finally{
                        try {
                            con.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }
        try {
            cdl.await();
            long spendtime=System.currentTimeMillis()-starttime;
            System.out.println( ThreadNum+"个线程花费时间:"+spendtime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) throws Exception {
        ThreadImport ti=new ThreadImport();
        ti.multiThreadImport(1);
        ti.multiThreadImport(5);
        ti.multiThreadImport(8);
        ti.multiThreadImport(10);
        ti.multiThreadImport(20);
        ti.multiThreadImport(40);
        System.out.println("笔记本CPU数:"+Runtime.getRuntime().availableProcessors());
    }

}

运行结果:

1个线程花费时间:56707
5个线程花费时间:21688
8个线程花费时间:16625
10个线程花费时间:16098
20个线程花费时间:19882
40个线程花费时间:23536
笔记本CPU数:8

发现在一定数量的线程下性能提升的还是很明显。

在实际的项目中,使用了连接池的情况下,多线程(在一定范围内)数据插入的性能还要明显一点。

  • 7
    点赞
  • 27
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
好的,以下是使用多线程进行数据库插入大量数据的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 InsertDataMultiThread { private static final String DB_DRIVER = "com.mysql.jdbc.Driver"; private static final String DB_CONNECTION = "jdbc:mysql://localhost:3306/mydatabase"; private static final String DB_USER = "root"; private static final String DB_PASSWORD = "password"; private static final int THREAD_POOL_SIZE = 10; private static final int BATCH_SIZE = 1000; public static void main(String[] args) { Connection dbConnection = null; try { // 获取数据库连接 dbConnection = getDBConnection(); // 设置自动提交为 false dbConnection.setAutoCommit(false); // 创建一个线程池 ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE); // 创建一个 PreparedStatement 对象 PreparedStatement preparedStatement = dbConnection.prepareStatement("INSERT INTO mytable (col1, col2, col3) VALUES (?, ?, ?)"); // 构造数据列表 List<Data> dataList = new ArrayList<>(); for (int i = 0; i < 1000000; i++) { Data data = new Data("value1", "value2", "value3"); dataList.add(data); } // 将数据列表分割成多个批次 List<List<Data>> batches = splitIntoBatches(dataList, BATCH_SIZE); // 依次将每个批次提交到线程池中执行 for (List<Data> batch : batches) { Runnable task = new InsertDataTask(preparedStatement, batch); executor.execute(task); } // 关闭线程池 executor.shutdown(); // 等待所有任务执行完毕 while (!executor.isTerminated()) {} // 提交事务 dbConnection.commit(); System.out.println("Data inserted successfully."); } catch (SQLException e) { System.err.println(e.getMessage()); } finally { try { if (dbConnection != null) { // 恢复自动提交 dbConnection.setAutoCommit(true); // 关闭数据库连接 dbConnection.close(); } } catch (SQLException e) { System.err.println(e.getMessage()); } } } private static Connection getDBConnection() throws SQLException { Connection dbConnection = null; try { Class.forName(DB_DRIVER); } catch (ClassNotFoundException e) { System.err.println(e.getMessage()); } dbConnection = DriverManager.getConnection(DB_CONNECTION, DB_USER, DB_PASSWORD); return dbConnection; } private static <T> List<List<T>> splitIntoBatches(List<T> list, int batchSize) { List<List<T>> batches = new ArrayList<>(); int size = list.size(); for (int i = 0; i < size; i += batchSize) { batches.add(list.subList(i, Math.min(size, i + batchSize))); } return batches; } private static class InsertDataTask implements Runnable { private PreparedStatement preparedStatement; private List<Data> dataList; public InsertDataTask(PreparedStatement preparedStatement, List<Data> dataList) { this.preparedStatement = preparedStatement; this.dataList = dataList; } @Override public void run() { try { for (Data data : dataList) { preparedStatement.setString(1, data.getCol1()); preparedStatement.setString(2, data.getCol2()); preparedStatement.setString(3, data.getCol3()); preparedStatement.addBatch(); } preparedStatement.executeBatch(); } catch (SQLException e) { System.err.println(e.getMessage()); } } } private static class Data { private String col1; private String col2; private String col3; public Data(String col1, String col2, String col3) { this.col1 = col1; this.col2 = col2; this.col3 = col3; } public String getCol1() { return col1; } public void setCol1(String col1) { this.col1 = col1; } public String getCol2() { return col2; } public void setCol2(String col2) { this.col2 = col2; } public String getCol3() { return col3; } public void setCol3(String col3) { this.col3 = col3; } } } ``` 在这个示例代码中,我们使用了线程池来并发执行大量数据库插入操作。每个线程负责将一个批次的数据插入数据库中。我们将数据列表分割成多个批次,每个批次的大小为 BATCH_SIZE,然后依次将每个批次提交到线程池中执行。在每个线程中,我们使用 PreparedStatement 对象来执行批量插入操作,可以有效地减少数据库连接和交互的次数。当所有任务执行完毕后,我们提交事务并关闭数据库连接。 如果你想要使用这个示例代码,需要将 DB_CONNECTION、DB_USER 和 DB_PASSWORD 替换成你自己的数据库连接信息,同时需要创建一个名为 mytable 的表,并且包含三个文本列 col1、col2 和 col3。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值