先说点背景

咱们这几天在Zuo数据迁移，手里拿着十万条用户记录。

你说这事儿挺常见的吧，毕竟老系统迁移到新系统，数据搬迁是必经之路。

但我一跑起来——五分钟！

那时领导就开始问：Neng不Neng快点啊？

先拆解一下到底慢在哪

先别急着去写代码，先想想原理。

每插入一条记录，就得：

- 发一次网络请求。

- 数据库解析一句 SQL。

- 提交一次事务。

十万条，就是十万次往返、十万次解析、十万次提交。

网络往返是大杀器

每一次往返dou要走 TCP/IP 协议栈，再加上数据库端的解析耗时。

事务提交也不是免费的

默认情况下每条 insert dou会单独开启和提交事务。那种“每条dou提交”的方式真的hen低效。

Mysql 的缓存机制没发挥作用

If you open a normal session，你的 SQL 会立刻送到服务器执行。没法利用批处理缓存。

Mysql & Mybatis 的双重技巧：批量 + 重写语句

Mysql 驱动有个叫 rewriteBatchedStatements 的参数，打开它后驱动会把多条 INSERT 合并成一条geng长的 SQL 执行。这样就Neng把网络往返次数大幅降低。

BATCH 模式的使用方式

@Service
public class BatchInsertService {
    @Autowired
    private SqlSessionFactory sqlSessionFactory;
    public void highPerformanceBatchInsert {
        if ) return;
        int threadCount = Math.min.availableProcessors);
        int batchSize =  Math.ceil userList.size / threadCount);
        ExecutorService executor = Executors.newFixedThreadPool;
        CountDownLatch latch = new CountDownLatch;
        for  {
            int start = i * batchSize;
            int end   = Math.min * batchSize, userList.size);
            if ) { latch.countDown; continue;}
            List subList = new ArrayList<>);
            executor.submit -> {
                try { doBatchInsert; }
                finally { latch.countDown; }
            });
        }
        try{ latch.await; } catch{ Thread.currentThread.interrupt;}
        executor.shutdown;
    }
    private void doBatchInsert{
        try){
            UserMapper mapper = sqlSession.getMapper;
            for;i++){
                mapper.insert);
                if%500==0){
                    sqlSession.flushStatements;
                    sqlSession.clearCache;
                }
            }
            sqlSession.flushStatements;
            sqlSession.commit;
        }
    }
}

"听起来不错，但我还有点疑问"

- 为什么每隔500条 flush？为什么不是一次性全部 flush？

- Ru果 list 超过内存怎么办？我怕 OOM.

- 自增主键返回值会不会丢失？

A）flush 的原因与节拍控制

BATCH 模式下所有 SQL 会被缓存到内存，然后一次性发给数据库。但Ru果你一次性塞进十万条，那内存压力可不小。我们Ke以按节拍 flush 一下让驱动把缓冲区里的语句立即发出去，然后清空缓存。这样既保持了批处理带来的优势，又防止了内存爆炸。

B）关于 OOM 的解决思路

- 分页读取：一次只取 5k 或者10k 条数据，从而保证列表大小可控。

int pageSize=50000;
for{
    Listpaged=listByPage;
    if) break;
    batchInsert; // 调用上面实现
}

"嗯，好像Ke以避免 OOM，那自增主键呢" C）自增主键与 BATCH 模式的兼容性问题

BATCH 模式下Ru果你需要获取生成的主键，你必须：

- 使用 rewriteBatchedStatements 并且升级到 Mysql 驱动8.x 或以上，这样驱动会自动返回所有主键值；

"那Ru果是 Oracle 呢?" C++ Oracle 自动增长方案简述

- 用序列生成 ID；

INSERT INTO user
VALUES;

Mysql 参数优化再加一点细节调优

- 设置 max_allowed_packet 足够大，以防单个 INSERT 太长导致报错；

"好，现在快到哪里去?"——从30秒降到8秒再降到3秒的真实案例分享吧！ 第一步：分页 + 批量插入

// 简化版代码
int batchSize=10000;
for{
   Listbatches=getBatch;
   userMapper.batchInsert; // Mapper.xml 写 foreach
}

从五分钟直接降到了三十秒！这一步Yi经hen厉害了嘛~

第二步：多线程并行执行

@Service
public class ParallelBatchInsertService{
   @Autowired SqlSessionFactory ssf;
   public void parallelBatchInsert{
      int threads=Math.min!=null?
          Integer.parseInt):Runtime.getRuntime.availableProcessors);
      int sizePerThread=l.size/threads;
      ExecutorService es=Executors.newFixedThreadPool;
      Lists=new ArrayList<>;
      for{
         int start=t*sizePerThread;
         int end=?l.size:*sizePerThread;
         Listm=l.subList;
         s.add->{batchInsertWithExecutor;return null;}));
      }
      // 等待完成
      for{try{f.get;}catch{throw new RuntimeException;}}
      es.shutdown;
   }
   private void batchInsertWithExecutor{
       try){
           UserMapper mpr=s.getMapper;
           for;i++){
               mpr.insert);
               if%500==0){s.flushStatements;s.clearCache;}
           }
           s.flushStatements;s.commit;
       }
   }
}

结果——8 秒！还敢说慢吗？ 😎

第三步：细节再调优

- 当单批次太大时就拆成geng小块；

(Note：

---