mysql大数据量下的操作以及优化_大数据为什么没有 ps.addbatch-CSDN博客

本文链接：https://blog.csdn.net/u013573133/article/details/49180457

当我们操作mysql的时候，如果数据量很小，那么我们如何处理都没有问题。但是当一张表非常大的时候，我们一个大查询，一个堆大插入，一个count(*)，一个limit都是非常恐怖的，因此，我在下面说几种常用的优化方式。

当表数据非常多的时候，我们不能一次把查询结果load进内存中，那会以下就OOM的，需要采用流式读取，也就是Hibernate中的ScrollableResult的方式，它的底层实现就是jdbc的流式读取。

1. JDBC流式读取（Hibernate ScrollableResult）

读取操作开始遇到的问题是当sql查询数据量比较大时候程序直接抛错，或是读不出来ResultSet的next方法阻塞。

Root Casue: mysql driver 默认的行为是需要把整个结果全部读取到内存(ResultSet)中，才允许读取结果。当遇到大数据的时候，这显然会导致OOM。这显然与期望的行为不一致，期望的行为是jdbc流的方式读取，当结果从mysql服务端返回后立即开始读取处理。这样应用就不需要大量内存来存储这个结果集。

正确的jdbc流式读取代码：

PreparedStatement ps = connection.prepareStatement("select .. from ..", 
            ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

//forward only read only也是mysql 驱动的默认值，所以不指定也是可以的比如： PreparedStatement ps = connection.prepareStatement("select .. from ..");

ps.setFetchSize(Integer.MIN_VALUE); // 也可以修改jdbc url通过defaultFetchSize参数来设置，这样默认所以的返回结果都是通过流方式读取.

ResultSet rs = ps.executeQuery();

while (rs.next()) {
System.out.println(rs.getString("fieldName"));
}

代码分析：下面是mysql判断是否开启流式读取结果的方法，有三个条件forward-only，read-only，fatch size是Integer.MIN_VALUE

 
    /** 
   
  * We only stream result sets when they are forward-only, read-only, and the 
   
  * fetch size has been set to Integer.MIN_VALUE 
   
  * 
   
  * @return true if this result set should be streamed row at-a-time, rather 
   
  * than read all at once. 
   
  */ 
   
 protected boolean createStreamingResultSet() { 
   
     try { 
   
         synchronized(checkClosed().getConnectionMutex()) { 
   
             return ((this.resultSetType == java.sql.ResultSet.TYPE_FORWARD_ONLY) 
   
                  && (this.resultSetConcurrency == java.sql.ResultSet.CONCUR_READ_ONLY) && (this.fetchSize == Integer.MIN_VALUE)); 
   
         } 
   
     } catch (SQLException e) { 
   
         // we can't break the interface, having this be no-op in case of error is ok 
   
         return false; 
   
     } 
   
 }

2. JDBC批量写入

当需要很多的数据一次性写入表中。如果是一条一条的执行insert来写入，非常慢。

Root Cause: 第一，单条写入需要大量的Database 请求响应交互。每个insert请求都是一个独立的Transaction commit。这样网络延迟大的情况下多次请求会有大量的时间消耗的网络延迟上。第二，是由于每个Transaction，Database都会有刷新磁盘操作写事务日志，保证事务的持久性。由于每个事务只是写入一条数据，所以磁盘io利用率不高，因为对于磁盘io是按块来的，所以连续写入大量数据效率更好。

所以，必须改成批量插入的方式，减少请求数与Transaction。

下面是批量插入的例子：还有jdbc连接串必须加下rewriteBatchedStatements=true

 
    int batchSize = 1000; 
   
 PreparedStatement ps = connection.prepareStatement("insert into tb1 (c1,c2,c3...) values (?,?,?...)"); 
   
 for (int i = 0; i < list.size(); i++) { 
   
     ps.setXXX(list.get(i).getC1()); 
   
     ps.setYYY(list.get(i).getC2()); 
   
     ps.setZZZ(list.get(i).getC3()); 
   
     ps.addBatch(); 
   
     if ((i + 1) % batchSize == 0) { 
   
         ps.executeBatch(); 
   
     } 
   
 } 
   
 if (list.size() % batchSize != 0) { 
   
     ps.executeBatch(); 
   
 }

上面代码示例是每1000条数据发送一次请求。mysql驱动内部在应用端会把多次addBatch()的参数合并成一条multi value的insert语句发送给db去执行
比如insert into tb1(c1,c2,c3) values (v1,v2,v3),(v4,v5,v6),(v7,v8,v9)...
这样可以比每条一个insert 明显少很多请求。减少了网络延迟消耗时间与磁盘io时间,从而提高了tps。
。
代码分析: 从代码可以看出，
1 rewriteBatchedStatements=true，insert是参数化语句且不是insert ... select 或者 insert... on duplicate key update with an id=last_insert_id(...)的话会执行
executeBatchedInserts，也就是muti value的方式

2 rewriteBatchedStatements=true 语句是都是参数化(没有addbatch(sql)方式加入的)的而且mysql server版本在4.1以上语句超过三条，则执行executePreparedBatchAsMultiStatement
就是将多个语句通过;分隔一次提交多条sql。比如 "insert into tb1(c1,c2,c3) values (v1,v2,v3);insert into tb1(c1,c2,c3) values (v1,v2,v3)..."

3 其余的执行executeBatchSerially，也就是还是一条条处理

public void addBatch(String sql)throws SQLException {
    synchronized(checkClosed().getConnectionMutex()) {
        this.batchHasPlainStatements = true;

        super.addBatch(sql);
    }
}

public int[] executeBatch()throws SQLException {
    //...
    if (!this.batchHasPlainStatements
         && this.connection.getRewriteBatchedStatements()) {

        if (canRewriteAsMultiValueInsertAtSqlLevel()) {
            return executeBatchedInserts(batchTimeout);
        }

        if (this.connection.versionMeetsMinimum(4, 1, 0)
             && !this.batchHasPlainStatements
             && this.batchedArgs != null
             && this.batchedArgs.size() > 3 /* cost of option setting rt-wise */
        )
        {
            return executePreparedBatchAsMultiStatement(batchTimeout);
        }
    }

    return executeBatchSerially(batchTimeout);
    //.....
}

executeBatchedInserts相比executePreparedBatchAsMultiStatement的方式传输效率更好，因为一次请求只重复一次前面的insert table (c1,c2,c3)

mysql server 对请求报文的最大长度有限制,如果batch size 太大造成请求报文超过最大限制，mysql 驱动会内部按最大报文限制查分成多个报文。所以要真正减少提交次数

还要检查下mysql server的max_allowed_packet 否则batch size 再大也没用.

要想验证mysql 发送了正确的sql 有两种方式

1 抓包，下图是wireshark在应用端抓包mysql的报文

2 另一个办法是在mysql server端开启general log 可以查看mysql收到的所有sql

3 在jdbc url上加上参数traceProtocol=true 或者profileSQL=true or autoGenerateTestcaseScript=true

性能测试对比

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

import com.alibaba.druid.pool.DruidDataSource;

public class BatchInsert {
    
    public static void main(String[] args) throws SQLException {
        
        int batchSize = 1000;
        int insertCount = 1000;
        
        testDefault(batchSize, insertCount);
     
        testRewriteBatchedStatements(batchSize,insertCount);
       
    }
    
    private static void testDefault(int batchSize, int insertCount) throws SQLException {  
        
        long start = System.currentTimeMillis();
        
        doBatchedInsert(batchSize, insertCount,"");
        
        long end = System.currentTimeMillis();
        
        System.out.println("default:" + (end -start) + "ms");
    }

   
  
    private static void testRewriteBatchedStatements(int batchSize, int insertCount) throws SQLException {

        long start = System.currentTimeMillis();
        
        doBatchedInsert(batchSize, insertCount, "rewriteBatchedStatements=true");
        
        long end = System.currentTimeMillis();
        
        System.out.println("rewriteBatchedStatements:" + (end -start) + "ms");
    }
    
    
    private static void doBatchedInsert(int batchSize, int insertCount, String mysqlProperties) throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl("jdbc:mysql://ip:3306/test?" + mysqlProperties);
        dataSource.setUsername("name");
        dataSource.setPassword("password");
        
        dataSource.init();
        
        Connection connection = dataSource.getConnection();
        
        PreparedStatement preparedStatement = connection.prepareStatement("insert into Test (name,gmt_created,gmt_modified) values (?,now(),now())");
        
        for (int i = 0; i < insertCount; i++) {
            preparedStatement.setString(1, i+" ");
            preparedStatement.addBatch();
            if((i+1) % batchSize == 0) {
                preparedStatement.executeBatch();
            }
        }
        preparedStatement.executeBatch();
        
        connection.close();   
        
        dataSource.close();
    }

}

网络环境ping测试延迟是35ms ,测试结果：

default:75525ms

rewriteBatchedStatements:914ms

3. 批量更新

             //Session是持久层操作的基础，相当于JDBC中的Connection。 
   
             Session session = sessionFactory.openSession(); 
   
             try{  //为保持事务的原子性，必须捕捉异常。所有事务都放在这一代码块里。 
   
                 // 
    操作事务时(增、删、改)必须显式的调用Transaction,如果不启动Transaction，数据库不会有变化(默认：session.autoCommit=false)。 
   
                 Transaction tx = session.beginTransaction(); 
   
                 for(int i=0; i<=1000; i++){ 
   
                   Student stu = new Student(...); 
   
                   session.save(stu);//set value to stu 
   
    //批量更新：为防止内存不足，分成每20个一批发送过去。 如果不是大批量更新，则不需要这样 
   
                  if(i%20==0){
       
                      //强制内存中数据同步到mysql，sql打印出并执行，只是事务没有commit，其他的线程看不到 
   
                      session.flush(); 
   
                      session.clear(); 
   
                  } 
   
                 } 
   
                 //transaction commit默认会自动flush（查询之前、事务提交时都会自动flush,之前手动flush只是为了内存考虑）。 
   
                 tx.commit();//提交事务，Hibernate不喜欢抛异常，如有需要，自己捕捉。 
   
                 //查询方法。如果有必要，也可以用事务(调用Transaction) 
   
                 String hql = "from Student s where s.stuNo like ? and s.Sal > ?";//Student是类而不是表 
   
                 List list = session.createQuery(hql) 
   
                                    .setString(0, "a00_").setDouble(1, 3000.0)//设置HQL的第一二个问号取值 
   
                                    .list();//Hibernate里面，没有返回值的都默认返回List 
   
                 StringBuffer sb = new StringBuffer(); 
   
                 for(Student st :(List<Student>)list){//(List<Student>)强制类型转换 
   
                   sb.append(st.getOid()+"  "+st.getName()+"\n");//拿到Student类里的属性 
   
                 } 
   
                 System.out.print(sb.toString());//直接打印sb也可以，它也是调用toString，但这样写效率更高 
   
             } catch (HibernateException e) { 
   
                 e.printStackTrace(); 
   
                 session.getTransaction().rollback();//如果事务不成功，则rollback 
   
             } finally { 
   
      // 如果是openSession()方法创建的session，必须手动关闭 
   
    session.close();//注意关闭顺序，session先关，Factory最后关(因为它可以启动多个session) 
   
                 sessionFactory.close();//关闭SessionFactory，虽然这里没看到它，但在HbnUtil里开启了。 
   
             }