转自：http://www.cnblogs.com/ysw-go/
数据库事务的隔离级别
对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:
脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段. 之后, 若 T2 回滚, T1读取的内容就是临时且无效的.
不可重复读: 对于两个事务 T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段. 之后, T1再次读取同一个字段, 值就不同了.
幻读: 对于两个事务 T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行. 之后, 如果 T1 再次读取同一个表, 就会多出几行.
数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题.
一个事务与其他事务隔离的程度称为隔离级别. 数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱
数据库提供的 4 种事务隔离级别:
Oracle 支持的 2 种事务隔离级别：READ COMMITED, SERIALIZABLE. Oracle 默认的事务隔离级别为: READ COMMITED
Mysql 支持 4 中事务隔离级别. Mysql 默认的事务隔离级别为: REPEATABLE READ
具体代码实现：
1 /**
2 * ID1 给 ID2 500钱
3 * 关于事务:
4 * 1.如果多个操作，每个使用自己单独的连接,则无法保证事务 例 test1演示
5 * 2.具体步骤:
6 * 1) 事务开始前,取消Connection 的默认的自动提交 setAutoCommit(false);
7 * 2) 如果事务的操作都成功,那么就提交事务
8 * 3)否则在 try-catch块中回滚
9 * try {
10 *
11 * conn.setAutoCommit(false);
12 * ...
13 * conn.commit();
14 * }catch{
15 * ...
16 * conn.rollback();
17 * }
18 */
19 @Test
20 public void test2(){
21
22 Connection conn = null;
23 try {
24 conn = JDBC_Tools.getConnection();
25 //System.out.println(conn.getAutoCommit());
26
27 // 1) 取消自动提交
28 conn.setAutoCommit(false);
29
30 String sql = "UPDATE rent set money = "
31 + "money - 500 where id = ?";
32
33 // 2) 如果事务的操作都成功,那么就提交事务
34 update(conn,sql, 1);
35
36 //int i = 1 / 0;
37
38 sql = "UPDATE rent set money = "
39 + "money + 500 where id = ?";
40 update(conn,sql, 2);
41 conn.commit();
42 } catch (Exception e) {
43 e.printStackTrace();
44
45 // 3)否则在 try-catch块中回滚
46 try {
47 conn.rollback();
48 } catch (SQLException e1) {
49 e1.printStackTrace();
50 }
51
52 }finally{
53 JDBC_Tools.relaseSource(conn, null);
54 }
55 }
56 public static void update(Connection conn,String sql,Object...objs){
57
58 PreparedStatement ps =null;
59 try {
60 ps = conn.prepareStatement(sql);
61
62 for(int i = 0;i<objs.length;i++){
63 ps.setObject(i+1, objs[i]);
64 }
65 ps.executeUpdate();
66 } catch (Exception e) {
67 e.printStackTrace();
68 }finally{
69 JDBC_Tools.relaseSource(null, ps);
70 }
71 }
72
73 @Test
74 public void test1() {
75
76 String sql = "UPDATE rent set money = "
77 + "money - 500 where id = ?";
78 DAO.update(sql, 1);
79
80 int i = 1 / 0; //一旦出现异常, ID1 减了500,但是 ID2 的钱并没有增加
81
82 sql = "UPDATE rent set money = "
83 + "money + 500 where id = ?";
84 DAO.update(sql, 2);
85 }设置隔离级别
86
87 public static <E> E getForValue(String sql){
88
89 //1. 得到结果集，该结果只有一行一列
90 Connection conn = null;
91 PreparedStatement ps = null;
92 ResultSet rs = null;
93 try {
94 //1. 获取数据库连接
95 conn = JDBC_Tools.getConnection();//System.out.println(conn.getTransactionIsolation());
96 conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
97 //2. 获取 PreparedStatement 对象
98 ps = conn.prepareStatement(sql);
99 //2. 取得结果
100 rs = ps.executeQuery();
101 if(rs.next()){
102 return (E)rs.getObject(1);
103 }
104 }catch(Exception e){
105 e.printStackTrace();
106 }finally{
107 JDBC_Tools.relaseSource(rs,conn, ps);
108 }
109 return null;
110 }
在 MySql 中设置隔离级别
具体代码实现：
1 public static <E> E getForValue(String sql){
2
3 //1. 得到结果集，该结果只有一行一列
4 Connection conn = null;
5 PreparedStatement ps = null;
6 ResultSet rs = null;
7 try {
8 //1. 获取数据库连接
9 conn = JDBC_Tools.getConnection();//System.out.println(conn.getTransactionIsolation());
10 conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
11 //2. 获取 PreparedStatement 对象
12 ps = conn.prepareStatement(sql);
13 //2. 取得结果
14 rs = ps.executeQuery();
15 if(rs.next()){
16 return (E)rs.getObject(1);
17 }
18 }catch(Exception e){
19 e.printStackTrace();
20 }finally{
21 JDBC_Tools.relaseSource(rs,conn, ps);
22 }
23 return null;
24 }
启动一个 mysql 程序, 就会获得一个单独的数据库连接. 每个数据库连接都有一个全局变量 @@tx_isolation, 表示当前的事务隔离级别. MySQL 默认的隔离级别为 Repeatable Read
查看当前的隔离级别: SELECT @@tx_isolation;
设置当前 mySQL 连接的隔离级别:
set transaction isolation level read committed;
设置数据库系统的全局的隔离级别:
set global transaction isolation level read committed;
JDBC批量执行
当需要成批插入或者更新记录时。可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率
/**
* 向mysql的testJ数据表中插入100000条记录
* 测试如何插入用时最短
* 版本一：使用Statement
*/
版本一：我们使用Statement进行事务的操作
1 @Test
2 public void testBatchWithStatement(){
3 Connection connection=null;
4 Statement statement=null;
5 String sql;
6 try {
7 connection=JDBCTools.getConnection();
8 //放到一个事务里面
9 JDBCTools.beginTx(connection);
10 statement=connection.createStatement();
11 long begin=System.currentTimeMillis();
12 for(int i=0;i<100000;i++){
13 sql="insert into testj values("+
14 (i+1)+", ‘name_"+ i+"‘, ‘2016-05-08‘)";
15 statement.execute(sql);
16 }
17 long end=System.currentTimeMillis();
18 System.out.println("Time:"+(end-begin));
19 JDBCTools.commit(connection);
20 } catch (Exception e) {
21 e.printStackTrace();
22 JDBCTools.rollback(connection);
23 }finally{
24 JDBCTools.release(null, statement, connection);
25 }
26 }
运行结果：
Time:8991
结论一：我们使用Statement插入100000条记录用时8991;
版本二：我们使用PreparedStatement进行事务的操作
1 @Test
2 public void testBatchWithPreparedStatement() {
3 Connection connection = null;
4 PreparedStatement preparedStatement = null;
5 String sql;
6 try {
7 connection = JDBCTools.getConnection();
8 // 放到一个事务里面
9 JDBCTools.beginTx(connection);
10 sql = "isnert into testJ values(?,?,?)";
11 preparedStatement = connection.prepareStatement(sql);
12 long begin = System.currentTimeMillis();
13 for (int i = 0; i < 100000; i++) {
14 preparedStatement.setInt(1, i + 1);
15 preparedStatement.setString(2, "name_" + i);
16 preparedStatement.setDate(3,
17 new Date(new java.util.Date().getTime()));
18 preparedStatement.execute();
19 }
20 long end = System.currentTimeMillis();
21 System.out.println("Time:" + (end - begin));
22 JDBCTools.commit(connection);
23 } catch (Exception e) {
24 e.printStackTrace();
25 JDBCTools.rollback(connection);
26 } finally {
27 JDBCTools.release(null, preparedStatement, connection);
28 }
29 }
运行结果：
Time:8563
结论2：因为我这里使用的是mysql数据库进行的操作，插入大量数据的时间性能方面的影响不是很大，如果我们换成oracle数据库或其他大型的关系型数据库，事务执行用时相比版本一的1/4;
版本三：批处理插入数据
1 @Test
2 public void testBatchWithBatch() {
3 Connection connection = null;
4 PreparedStatement preparedStatement = null;
5 String sql=null;
6 try {
7 connection = JDBCTools.getConnection();
8 // 放到一个事务里面
9 JDBCTools.beginTx(connection);
10 sql = "insert into testJ values(?,?,?)";
11 preparedStatement = connection.prepareStatement(sql);
12 long begin = System.currentTimeMillis();
13 for (int i = 0; i < 100000; i++) {
14 preparedStatement.setInt(1, i + 1);
15 preparedStatement.setString(2, "name_" + i);
16 preparedStatement.setDate(3,
17 new Date(new java.util.Date().getTime()));
18 //积攒SQL
19 preparedStatement.addBatch();
20 //当积攒到一定程度，就统一执行，并且清空先前积攒的SQL
21 if((i+1)%300==0){
22 //执行
23 preparedStatement.executeBatch();
24 //清空
25 preparedStatement.clearBatch();
26 }
27 }
28 //如果插入的记录数不是300的整倍数，再执行一次
29 if(100000%300!=0){
30 //执行
31 preparedStatement.executeBatch();
32 //清空
33 preparedStatement.clearBatch();
34 }
35 long end = System.currentTimeMillis();
36 System.out.println("Time:" + (end - begin));
37 JDBCTools.commit(connection);
38 } catch (Exception e) {
39 e.printStackTrace();
40 JDBCTools.rollback(connection);
41 } finally {
42 JDBCTools.release(null, preparedStatement, connection);
43 }
44 }
运行结果：4587(又提高了，但是还是不明显)
结论三：批处理事务建议采用版本三的方式，再次建议使用oracle数据库做这个插入数据事务的实验，mysql小数据还成，大量的数据也真呵呵了;
时间： 2024-10-08 19:14:58