JDBC批量Insert深度優化（沒事務）
JDBC批量Insert深度優化（沒事務）
最近在作一個數據同步分發工具，高併發，高效率，異步非實時是主要特色。
爲此，選擇的方案是JDBC、只有兩種操做，插入和更新。
對於更新，只能逐條分批就能夠了，優化空間不大。
對於插入，則能夠作批量的優化，優化的策略只能是具體問題具體分析，以測試結論爲主要依據了。
環境：
MySQL 5.1
RedHat Linux AS 5
JavaSE 1.5
DbConnectionBroker 微型數據庫鏈接池
測試的方案：
執行10萬次Insert語句，使用不一樣方式。
A組：靜態SQL，自動提交，沒事務控制（MyISAM引擎）
一、逐條執行10萬次
二、分批執行將10萬分紅m批，每批n條，分多種分批方案來執行。
B組：預編譯模式SQL，自動提交，沒事務控制（MyISAM引擎）
一、逐條執行10萬次
二、分批執行將10萬分紅m批，每批n條，分多種分批方案來執行。
-------------------------------------------------------------------------------------------
C組：靜態SQL，不自動提交，有事務控制（InnoDB引擎）
一、逐條執行10萬次
二、分批執行將10萬分紅m批，每批n條，分多種分批方案來執行。
D組：預編譯模式SQL，不自動提交，有事務控制（InnoDB引擎）
一、逐條執行10萬次
二、分批執行將10萬分紅m批，每批n條，分多種分批方案來執行。
本次主要測試A、B組，並得出測試結果。
SQL代碼
DROP
TABLE
IF
EXISTS tuser;
CREATE TABLE tuser (
id bigint(20) NOT NULL AUTO_INCREMENT,
name varchar(12) DEFAULT NULL,
remark varchar(24) DEFAULT NULL,
createtime datetime DEFAULT NULL,
updatetime datetime DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
CREATE TABLE tuser (
id bigint(20) NOT NULL AUTO_INCREMENT,
name varchar(12) DEFAULT NULL,
remark varchar(24) DEFAULT NULL,
createtime datetime DEFAULT NULL,
updatetime datetime DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
下面是A、B組的測試代碼：
package testbatch;
import java.io.IOException;
import java.sql.*;
/**
* JDBC批量Insert優化（上）
*
* @author leizhimin 2009-7-29 10:03:10
*/
public class TestBatch {
public static DbConnectionBroker myBroker = null;
static {
try {
myBroker = new DbConnectionBroker( "com.mysql.jdbc.Driver",
"jdbc:mysql://192.168.104.163:3306/testdb",
"vcom", "vcom", 2, 4,
"c:\\testdb.log", 0.01);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 初始化測試環境
*
* @throws SQLException 異常時拋出
*/
public static void init() throws SQLException {
Connection conn = myBroker.getConnection();
Statement stmt = conn.createStatement();
stmt.addBatch("DROP TABLE IF EXISTS tuser");
stmt.addBatch("CREATE TABLE tuser (\n" +
" id bigint(20) NOT NULL AUTO_INCREMENT,\n" +
" name varchar(12) DEFAULT NULL,\n" +
" remark varchar(24) DEFAULT NULL,\n" +
" createtime datetime DEFAULT NULL,\n" +
" updatetime datetime DEFAULT NULL,\n" +
" PRIMARY KEY (id)\n" +
") ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8");
stmt.executeBatch();
myBroker.freeConnection(conn);
}
/**
* 100000條靜態SQL插入
*
* @throws Exception 異常時拋出
*/
public static void testInsert() throws Exception {
init(); //初始化環境
Long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String sql = "\n" +
"insert into testdb.tuser \n" +
"\t(name, \n" +
"\tremark, \n" +
"\tcreatetime, \n" +
"\tupdatetime\n" +
"\t)\n" +
"\tvalues\n" +
"\t('" + RandomToolkit.generateString(12) + "', \n" +
"\t'" + RandomToolkit.generateString(24) + "', \n" +
"\tnow(), \n" +
"\tnow()\n" +
")";
Connection conn = myBroker.getConnection();
Statement stmt = conn.createStatement();
stmt.execute(sql);
myBroker.freeConnection(conn);
}
Long end = System.currentTimeMillis();
System.out.println("單條執行100000條Insert操做，共耗時：" + (end - start) / 1000f + "秒！");
}
/**
* 批處理執行靜態SQL測試
*
* @param m 批次
* @param n 每批數量
* @throws Exception 異常時拋出
*/
public static void testInsertBatch(int m, int n) throws Exception {
init(); //初始化環境
Long start = System.currentTimeMillis();
for (int i = 0; i < m; i++) {
//從池中獲取鏈接
Connection conn = myBroker.getConnection();
Statement stmt = conn.createStatement();
for (int k = 0; k < n; k++) {
String sql = "\n" +
"insert into testdb.tuser \n" +
"\t(name, \n" +
"\tremark, \n" +
"\tcreatetime, \n" +
"\tupdatetime\n" +
"\t)\n" +
"\tvalues\n" +
"\t('" + RandomToolkit.generateString(12) + "', \n" +
"\t'" + RandomToolkit.generateString(24) + "', \n" +
"\tnow(), \n" +
"\tnow()\n" +
")";
//加入批處理
stmt.addBatch(sql);
}
stmt.executeBatch(); //執行批處理
// stmt.clearBatch(); //清理批處理
stmt.close();
myBroker.freeConnection(conn); //鏈接歸池
}
Long end = System.currentTimeMillis();
System.out.println("批量執行" + m + "*" + n + "=" + m * n + "條Insert操做，共耗時：" + (end - start) / 1000f + "秒！");
}
/**
* 100000條預約義SQL插入
*
* @throws Exception 異常時拋出
*/
public static void testInsert2() throws Exception { //單條執行100000條Insert操做，共耗時：40.422秒！
init(); //初始化環境
Long start = System.currentTimeMillis();
String sql = "" +
"insert into testdb.tuser\n" +
" (name, remark, createtime, updatetime)\n" +
"values\n" +
" (?, ?, ?, ?)";
for (int i = 0; i < 100000; i++) {
Connection conn = myBroker.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, RandomToolkit.generateString(12));
pstmt.setString(2, RandomToolkit.generateString(24));
pstmt.setDate(3, new Date(System.currentTimeMillis()));
pstmt.setDate(4, new Date(System.currentTimeMillis()));
pstmt.executeUpdate();
pstmt.close();
myBroker.freeConnection(conn);
}
Long end = System.currentTimeMillis();
System.out.println("單條執行100000條Insert操做，共耗時：" + (end - start) / 1000f + "秒！");
}
/**
* 批處理執行預處理SQL測試
*
* @param m 批次
* @param n 每批數量
* @throws Exception 異常時拋出
*/
public static void testInsertBatch2(int m, int n) throws Exception {
init(); //初始化環境
Long start = System.currentTimeMillis();
String sql = "" +
"insert into testdb.tuser\n" +
" (name, remark, createtime, updatetime)\n" +
"values\n" +
" (?, ?, ?, ?)";
for (int i = 0; i < m; i++) {
//從池中獲取鏈接
Connection conn = myBroker.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
for (int k = 0; k < n; k++) {
pstmt.setString(1, RandomToolkit.generateString(12));
pstmt.setString(2, RandomToolkit.generateString(24));
pstmt.setDate(3, new Date(System.currentTimeMillis()));
pstmt.setDate(4, new Date(System.currentTimeMillis()));
//加入批處理
pstmt.addBatch();
}
pstmt.executeBatch(); //執行批處理
// pstmt.clearBatch(); //清理批處理
pstmt.close();
myBroker.freeConnection(conn); //鏈接歸池
}
Long end = System.currentTimeMillis();
System.out.println("批量執行" + m + "*" + n + "=" + m * n + "條Insert操做，共耗時：" + (end - start) / 1000f + "秒！");
}
public static void main(String[] args) throws Exception {
init();
Long start = System.currentTimeMillis();
System.out.println("--------A組測試----------");
testInsert();
testInsertBatch(100, 1000);
testInsertBatch(250, 400);
testInsertBatch(400, 250);
testInsertBatch(500, 200);
testInsertBatch(1000, 100);
testInsertBatch(2000, 50);
testInsertBatch(2500, 40);
testInsertBatch(5000, 20);
Long end1 = System.currentTimeMillis();
System.out.println("B組測試過程結束，所有測試耗時：" + (end1 - start) / 1000f + "秒！");
System.out.println("--------B組測試----------");
testInsert2();
testInsertBatch2(100, 1000);
testInsertBatch2(250, 400);
testInsertBatch2(400, 250);
testInsertBatch2(500, 200);
testInsertBatch2(1000, 100);
testInsertBatch2(2000, 50);
testInsertBatch2(2500, 40);
testInsertBatch2(5000, 20);
Long end2 = System.currentTimeMillis();
System.out.println("B組測試過程結束，所有測試耗時：" + (end2 - end1) / 1000f + "秒！");
}
}
import java.io.IOException;
import java.sql.*;
/**
* JDBC批量Insert優化（上）
*
* @author leizhimin 2009-7-29 10:03:10
*/
public class TestBatch {
public static DbConnectionBroker myBroker = null;
static {
try {
myBroker = new DbConnectionBroker( "com.mysql.jdbc.Driver",
"jdbc:mysql://192.168.104.163:3306/testdb",
"vcom", "vcom", 2, 4,
"c:\\testdb.log", 0.01);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 初始化測試環境
*
* @throws SQLException 異常時拋出
*/
public static void init() throws SQLException {
Connection conn = myBroker.getConnection();
Statement stmt = conn.createStatement();
stmt.addBatch("DROP TABLE IF EXISTS tuser");
stmt.addBatch("CREATE TABLE tuser (\n" +
" id bigint(20) NOT NULL AUTO_INCREMENT,\n" +
" name varchar(12) DEFAULT NULL,\n" +
" remark varchar(24) DEFAULT NULL,\n" +
" createtime datetime DEFAULT NULL,\n" +
" updatetime datetime DEFAULT NULL,\n" +
" PRIMARY KEY (id)\n" +
") ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8");
stmt.executeBatch();
myBroker.freeConnection(conn);
}
/**
* 100000條靜態SQL插入
*
* @throws Exception 異常時拋出
*/
public static void testInsert() throws Exception {
init(); //初始化環境
Long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String sql = "\n" +
"insert into testdb.tuser \n" +
"\t(name, \n" +
"\tremark, \n" +
"\tcreatetime, \n" +
"\tupdatetime\n" +
"\t)\n" +
"\tvalues\n" +
"\t('" + RandomToolkit.generateString(12) + "', \n" +
"\t'" + RandomToolkit.generateString(24) + "', \n" +
"\tnow(), \n" +
"\tnow()\n" +
")";
Connection conn = myBroker.getConnection();
Statement stmt = conn.createStatement();
stmt.execute(sql);
myBroker.freeConnection(conn);
}
Long end = System.currentTimeMillis();
System.out.println("單條執行100000條Insert操做，共耗時：" + (end - start) / 1000f + "秒！");
}
/**
* 批處理執行靜態SQL測試
*
* @param m 批次
* @param n 每批數量
* @throws Exception 異常時拋出
*/
public static void testInsertBatch(int m, int n) throws Exception {
init(); //初始化環境
Long start = System.currentTimeMillis();
for (int i = 0; i < m; i++) {
//從池中獲取鏈接
Connection conn = myBroker.getConnection();
Statement stmt = conn.createStatement();
for (int k = 0; k < n; k++) {
String sql = "\n" +
"insert into testdb.tuser \n" +
"\t(name, \n" +
"\tremark, \n" +
"\tcreatetime, \n" +
"\tupdatetime\n" +
"\t)\n" +
"\tvalues\n" +
"\t('" + RandomToolkit.generateString(12) + "', \n" +
"\t'" + RandomToolkit.generateString(24) + "', \n" +
"\tnow(), \n" +
"\tnow()\n" +
")";
//加入批處理
stmt.addBatch(sql);
}
stmt.executeBatch(); //執行批處理
// stmt.clearBatch(); //清理批處理
stmt.close();
myBroker.freeConnection(conn); //鏈接歸池
}
Long end = System.currentTimeMillis();
System.out.println("批量執行" + m + "*" + n + "=" + m * n + "條Insert操做，共耗時：" + (end - start) / 1000f + "秒！");
}
/**
* 100000條預約義SQL插入
*
* @throws Exception 異常時拋出
*/
public static void testInsert2() throws Exception { //單條執行100000條Insert操做，共耗時：40.422秒！
init(); //初始化環境
Long start = System.currentTimeMillis();
String sql = "" +
"insert into testdb.tuser\n" +
" (name, remark, createtime, updatetime)\n" +
"values\n" +
" (?, ?, ?, ?)";
for (int i = 0; i < 100000; i++) {
Connection conn = myBroker.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, RandomToolkit.generateString(12));
pstmt.setString(2, RandomToolkit.generateString(24));
pstmt.setDate(3, new Date(System.currentTimeMillis()));
pstmt.setDate(4, new Date(System.currentTimeMillis()));
pstmt.executeUpdate();
pstmt.close();
myBroker.freeConnection(conn);
}
Long end = System.currentTimeMillis();
System.out.println("單條執行100000條Insert操做，共耗時：" + (end - start) / 1000f + "秒！");
}
/**
* 批處理執行預處理SQL測試
*
* @param m 批次
* @param n 每批數量
* @throws Exception 異常時拋出
*/
public static void testInsertBatch2(int m, int n) throws Exception {
init(); //初始化環境
Long start = System.currentTimeMillis();
String sql = "" +
"insert into testdb.tuser\n" +
" (name, remark, createtime, updatetime)\n" +
"values\n" +
" (?, ?, ?, ?)";
for (int i = 0; i < m; i++) {
//從池中獲取鏈接
Connection conn = myBroker.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
for (int k = 0; k < n; k++) {
pstmt.setString(1, RandomToolkit.generateString(12));
pstmt.setString(2, RandomToolkit.generateString(24));
pstmt.setDate(3, new Date(System.currentTimeMillis()));
pstmt.setDate(4, new Date(System.currentTimeMillis()));
//加入批處理
pstmt.addBatch();
}
pstmt.executeBatch(); //執行批處理
// pstmt.clearBatch(); //清理批處理
pstmt.close();
myBroker.freeConnection(conn); //鏈接歸池
}
Long end = System.currentTimeMillis();
System.out.println("批量執行" + m + "*" + n + "=" + m * n + "條Insert操做，共耗時：" + (end - start) / 1000f + "秒！");
}
public static void main(String[] args) throws Exception {
init();
Long start = System.currentTimeMillis();
System.out.println("--------A組測試----------");
testInsert();
testInsertBatch(100, 1000);
testInsertBatch(250, 400);
testInsertBatch(400, 250);
testInsertBatch(500, 200);
testInsertBatch(1000, 100);
testInsertBatch(2000, 50);
testInsertBatch(2500, 40);
testInsertBatch(5000, 20);
Long end1 = System.currentTimeMillis();
System.out.println("B組測試過程結束，所有測試耗時：" + (end1 - start) / 1000f + "秒！");
System.out.println("--------B組測試----------");
testInsert2();
testInsertBatch2(100, 1000);
testInsertBatch2(250, 400);
testInsertBatch2(400, 250);
testInsertBatch2(500, 200);
testInsertBatch2(1000, 100);
testInsertBatch2(2000, 50);
testInsertBatch2(2500, 40);
testInsertBatch2(5000, 20);
Long end2 = System.currentTimeMillis();
System.out.println("B組測試過程結束，所有測試耗時：" + (end2 - end1) / 1000f + "秒！");
}
}
運行結果：
--------A組測試----------
單條執行100000條Insert操做，共耗時：36.766秒！
批量執行100*1000=100000條Insert操做，共耗時：33.625秒！
批量執行250*400=100000條Insert操做，共耗時：35.063秒！
批量執行400*250=100000條Insert操做，共耗時：35.296秒！
批量執行500*200=100000條Insert操做，共耗時：37.016秒！
批量執行1000*100=100000條Insert操做，共耗時：35.953秒！
批量執行2000*50=100000條Insert操做，共耗時：36.265秒！
批量執行2500*40=100000條Insert操做，共耗時：36.625秒！
批量執行5000*20=100000條Insert操做，共耗時：37.234秒！
B組測試過程結束，所有測試耗時：323.906秒！
--------B組測試----------
單條執行100000條Insert操做，共耗時：44.188秒！
批量執行100*1000=100000條Insert操做，共耗時：34.235秒！
批量執行250*400=100000條Insert操做，共耗時：34.328秒！
批量執行400*250=100000條Insert操做，共耗時：34.032秒！
批量執行500*200=100000條Insert操做，共耗時：33.625秒！
批量執行1000*100=100000條Insert操做，共耗時：34.125秒！
批量執行2000*50=100000條Insert操做，共耗時：33.797秒！
批量執行2500*40=100000條Insert操做，共耗時：35.359秒！
批量執行5000*20=100000條Insert操做，共耗時：36.218秒！
B組測試過程結束，所有測試耗時：320.0秒！
單條執行100000條Insert操做，共耗時：36.766秒！
批量執行100*1000=100000條Insert操做，共耗時：33.625秒！
批量執行250*400=100000條Insert操做，共耗時：35.063秒！
批量執行400*250=100000條Insert操做，共耗時：35.296秒！
批量執行500*200=100000條Insert操做，共耗時：37.016秒！
批量執行1000*100=100000條Insert操做，共耗時：35.953秒！
批量執行2000*50=100000條Insert操做，共耗時：36.265秒！
批量執行2500*40=100000條Insert操做，共耗時：36.625秒！
批量執行5000*20=100000條Insert操做，共耗時：37.234秒！
B組測試過程結束，所有測試耗時：323.906秒！
--------B組測試----------
單條執行100000條Insert操做，共耗時：44.188秒！
批量執行100*1000=100000條Insert操做，共耗時：34.235秒！
批量執行250*400=100000條Insert操做，共耗時：34.328秒！
批量執行400*250=100000條Insert操做，共耗時：34.032秒！
批量執行500*200=100000條Insert操做，共耗時：33.625秒！
批量執行1000*100=100000條Insert操做，共耗時：34.125秒！
批量執行2000*50=100000條Insert操做，共耗時：33.797秒！
批量執行2500*40=100000條Insert操做，共耗時：35.359秒！
批量執行5000*20=100000條Insert操做，共耗時：36.218秒！
B組測試過程結束，所有測試耗時：320.0秒！
上面的測試結果彷佛在乎料以外，看來是用鏈接池技術，各類執行方式性能差別不是很大。細心觀察測試結果，能夠得出一些結論。
結論：
如下結論以測試的環境和組別爲前提：
數據庫鏈接池控制下，單線程，自動提交，沒事務控制（MyISAM引擎）
一、預約義SQL並無想象中的那麼高效，由於兩組測試結果相差3秒，最短執行時間均爲33.625秒！單項測試結果各有勝出。
二、批量執行時，分批的大小對效率影響也很大，靜態SQL以200-1000條分批執行爲宜。預處理SQL以50-400條爲宜。
三、經過結果看，預處理SQL效率稍稍勝出，所以批量執行時候優先選擇預約義SQL，預約義SQL還有個好處就是消耗的內存較少。靜態SQL串會佔用大量的內存資源，容易致使內存溢出的問題。
四、在批處理執行的時候，每批執行完成後，最好顯式的調用pstmt.close()或stmt.close()方法，以便儘快釋放執行過的SQL語句，提升內存利用率。
五、談到優化方式，上面的批處理就是很好的優化策略。
六、數據庫鏈接池能夠大大提升效率，若是沒有鏈接池管理，效率會大大下降，但無論怎麼鏈接，上面的優化策略都是有效的。
相關文章
- 1. JDBC批量Insert深度優化（有事務）
- 2. sqlite3 批量insert的性能優化
- 3. jdbc批量執行SQL insert 操做
- 4. JDBC事務與批量處理(轉載)
- 5. JDBC批量插入優化addbatch
- 6. mybatis 批量insert
- 7. springboot-mybatis 批量insert
- 8. MyBatis中批量insert
- 9. mysql批量insert速度超慢
- 10. Mysql 批量update和批量insert詳解
- 更多相關文章...
- • SEO - 搜索引擎優化 - 網站建設指南
- • SQLite 事務（Transaction） - SQLite教程
- • 算法總結-深度優先算法
- • 算法總結-廣度優先算法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點
歡迎關注本站公眾號,獲取更多信息
