java解决大数据量查询慢 jdbc查询大数据量优化

转载

mob64ca13fb1f2e 2024-04-16 21:39:55

文章标签 java解决大数据量查询慢 jdbc 优化 string null 文章分类 Java 后端开发

这个就是做个练习.想看下JDBC的最大优化度.
我的要求就是插入到数据库里大量的数据比如10W 或者 100W 而且要求内存稳定.
首先说下我的代码:
我的数据库MySQL

CREATE TABLE `users` (
  `id` int(11) NOT NULL auto_increment,
  `firstname` varchar(50) NOT NULL,
  `lastname` varchar(50) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

我的数据库辅助类

package com.jdbc.batch;

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

public final class DBUtils {
    private static String mysqlurl = "jdbc:mysql://localhost:3306/mytest";
    private static String accessurl = "jdbc:mysql://localhost:3306/mytest";
    private static String user = "root";
    private static String password = "root";

    // 获得连接
    public static Connection getAccessConn() throws SQLException {
        return DriverManager.getConnection(accessurl, user, password);
    }
    
    public static Connection getMySqlConn() throws SQLException {
        return DriverManager.getConnection(mysqlurl, user, password);
    }

    // 释放连接
    public static void free(ResultSet rs, PreparedStatement ps, Connection conn) {
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ps != null) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {

                try {
                    if (conn != null) {
                        conn.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }

            }

        }

    }

    // 加载驱动
    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            System.out.println("驱动加载出错");
        }
    }

}

测试类

package com.jdbc.batch;

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

public class BatchExample {
    private static Connection mysqlConn = null;
    private static ResultSet rs = null;
    // 总条数
    private static int allCount = 10000;
    // 分批条数
    private static int preCount = 1000;
    // 计数器
    private static int count = 0;

    private static String insertSQL = "insert into users(firstname, lastname, age) values(?, ?, ?)";

    private static PreparedStatement mysqlPs = null;

    public static void main(String[] args) throws SQLException {
        try {
            mysqlConn = DBUtils.getMySqlConn();
            mysqlPs = mysqlConn.prepareStatement(insertSQL);
            mysqlConn.setAutoCommit(false);
            long start = System.currentTimeMillis();
            
            for (int i = 1; i <= allCount; i++) {
                mysqlPs.setString(1, "firstname" + i);
                mysqlPs.setString(2, "lastname" + i);
                mysqlPs.setInt(3, 23);
                mysqlPs.addBatch();        
                if ((i % preCount) == 0){
                    mysqlPs.executeBatch();
                    System.out.println("当前进行完毕===>" + (++count) * preCount + "条");
                }
            }        
            long end = System.currentTimeMillis();
            System.out.println("数据导入完毕,所用时间为: " + (end - start) + " ms");

        } catch (Exception e) {
            mysqlConn.rollback();
            System.out.println("数据出错,已进行回滚");
            throw new RuntimeException();
        } finally {
            mysqlConn.commit();
            DBUtils.free(rs, mysqlPs, mysqlConn);
        }
    }

}

我用的批处理.最后执行10000条的记录是

当前进行完毕===>1000条
当前进行完毕===>2000条
当前进行完毕===>3000条
当前进行完毕===>4000条
当前进行完毕===>5000条
当前进行完毕===>6000条
当前进行完毕===>7000条
当前进行完毕===>8000条
当前进行完毕===>9000条
当前进行完毕===>10000条
数据导入完毕,所用时间为: 8140 ms

而我换了一种方案用executeUpdate一次提交.SQL用StringBuilder串接效率提升很快.
代码

package com.jdbc.batch;

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

public class BufferQuery {
    private static Connection mysqlConn = null;
    private static ResultSet rs = null;
    // 总条数
    private static int allCount = 10000;
    // 分批条数
    private static int preCount = 1000;
    // 计数器
    private static int count = 0;

    private static String insertSQL = "insert into users(firstname, lastname, age) values(?, ?, ?)";

    private static PreparedStatement mysqlPs = null;

    public static void main(String[] args) throws SQLException {
        try {
            StringBuilder sb = new StringBuilder();
            sb.append("insert into users(firstname, lastname, age) values");
            mysqlConn = DBUtils.getMySqlConn();
            mysqlPs = mysqlConn.prepareStatement(insertSQL);
            mysqlConn.setAutoCommit(false);
            long start = System.currentTimeMillis();
            
            for (int i = 1; i <= allCount; i++) {
                if(i > 1) sb.append(",");
                sb.append("('aa"+ i +"','bb',23)");    

                if(i % preCount == 0){
                    System.out.println("导入进行===>" + (++count * preCount) + "条");                
                }                
            }
            mysqlPs.executeUpdate(sb.toString());
            
            
            long end = System.currentTimeMillis();
            System.out.println("数据导入完毕,所用时间为: " + (end - start) + " ms");

        } catch (Exception e) {
            mysqlConn.rollback();
            System.out.println("数据出错,已进行回滚");
            throw new RuntimeException();
        } finally {
            mysqlConn.commit();
            DBUtils.free(rs, mysqlPs, mysqlConn);
        }
    }

}

// 用的StringBuilder串接
           long start = System.currentTimeMillis();
            
            for (int i = 1; i <= allCount; i++) {
                if(i > 1) sb.append(",");
                sb.append("('aa"+ i +"','bb',23)");    

                if(i % preCount == 0){
                    System.out.println("导入进行===>" + (++count * preCount) + "条");                
                }                
            }
            mysqlPs.executeUpdate(sb.toString());

导入进行===>1000条
导入进行===>2000条
导入进行===>3000条
导入进行===>4000条
导入进行===>5000条
导入进行===>6000条
导入进行===>7000条
导入进行===>8000条
导入进行===>9000条
导入进行===>10000条
数据导入完毕,所用时间为: 219 ms

1W条才129ms为什么会比批处理快这么多.但是还有问题就是如果数据量更大如20W 那么StringBuilder就装不下堆栈溢出....

stringbuilder 看了msdn，发现最大的长度是Int32，开始没有理解，后来HJ告诉我能够至少容纳3M的长度，我又去check了一下msdn，最大的长度是2的32次方（2的32次方就是4G），但是网上有人说是2G，那就是2的31次方。

要注意的是stringbuilder非线程安全用再多线程处理时要慎用

我测试的jdbc批处理操作，插入112万条数据的对比
批量向数据表插入一条数据（包含一个float值）
建立表个数每个表插入数据条数单个数据表耗时（毫秒）数据库连接耗时（毫秒）带数据库连接总耗时（毫秒）不带数据库连接总耗时（毫秒）备注
800 1440 480-600 312 437703 437391 调用Statement.execute批量插入
800 1440 100-200 328 118985 118657 调用Statement.addBatch批量插入
800 1440 40-110 313 56922 56609 调用PreparedStatement.addBatch批量插入

使用jdbc向数据库插入100000条记录，分别使用statement，PreparedStatement，及PreparedStatement+批处理3种方式进行测试：

　　1、使用statement插入100000条记录

public void exec(Connection conn){
　　try {
　　Long beginTime = System.currentTimeMillis();
　　conn.setAutoCommit(false);//设置手动提交
　　Statement st = conn.createStatement();
　　for(int i=0;i<100000;i++){
　　String sql="insert into t1(id) values ("+i+")";
　　st.executeUpdate(sql);
　　}
　　Long endTime = System.currentTimeMillis();
　　System.out.println("st："+(endTime-beginTime)/1000+"秒");//计算时间
　　st.close();
　　conn.close();
　　} catch (SQLException e) {
　　// TODO Auto-generated catch block
　　e.printStackTrace();
　　}
　　}

　　2、使用PreparedStatement对象

public void exec2(Connection conn){
　　try {
　　Long beginTime = System.currentTimeMillis();
　　conn.setAutoCommit(false);//手动提交
　　PreparedStatement pst = conn.prepareStatement("insert into t1(id) values (?)");
　　for(int i=0;i<100000;i++){
　　pst.setInt(1, i);
　　pst.execute();
　　}
　　conn.commit();
　　Long endTime = System.currentTimeMillis();
　　System.out.println("pst:"+(endTime-beginTime)/1000+"秒");//计算时间
　　pst.close();
　　conn.close();
　　} catch (SQLException e) {
　　// TODO Auto-generated catch block
　　e.printStackTrace();
　　}
　　}

wordend 相关阅读：

性能测试(并发负载压力)测试分析
软件性能测试的重要性及策略
软件性能测试入门

　　3、使用PreparedStatement + 批处理

public void exec3(Connection conn){
　　try {
　　conn.setAutoCommit(false);
　　Long beginTime = System.currentTimeMillis();
　　PreparedStatement pst = conn.prepareStatement("insert into t1(id) values (?)");
　　for(int i=1;i<=100000;i++){
　　pst.setInt(1, i);
　　pst.addBatch();
　　if(i%1000==0){//可以设置不同的大小;如50，100，500，1000等等
　　pst.executeBatch();
　　conn.commit();
　　pst.clearBatch();
　　}
　　}
　　Long endTime = System.currentTimeMillis();
　　System.out.println("pst+batch："+(endTime-beginTime)/1000+"秒");
　　pst.close();
　　conn.close();
　　} catch (SQLException e) {
　　// TODO Auto-generated catch block
　　e.printStackTrace();
　　}
　　}

　　在Oracle 10g中测试，结果：

　　1、使用statement耗时142秒;

　　2、使用PreparedStatement耗时56秒;

　　3、使用PreparedStatement + 批处理耗时：

　　a.50条插入一次，耗时5秒;

　　b.100条插入一次，耗时2秒;

　　c.1000条以上插入一次，耗时1秒;

　　通过以上可以得出结论，在使用jdbc大批量插入数据时，明显使用第三种方式(PreparedStatement + 批处理)性能更优。

　　当使用sqlserver 2000进行测试时，第三种方式最少耗时5秒，从这方面可以看出Oracle在处理大量数据时，明显性能更强。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。