事务隔离级别是由数据库系统实现的。

Java事务

1) 说到事务，不得不提的就是ACID特性，再次回顾：

Ø 原子性(atomicity)：组成事务处理的语句形成了一个逻辑单元，不能只执行其中的一部分。

Ø 一致性(consistency)：在事务处理执行前后，数据库是一致的(数据库数据完整性约束)。

Ø 隔离性(isolcation)：一个事务处理对另一个事务处理的影响。

Ø 持续性(durability)：事务处理的效果能够被永久保存下来 。

2) 然后就是事务在Java中的最基本操作：

Ø connection.setAutoCommit(false);//打开事务。

Ø connection.commit();//提交事务。

Ø connection.rollback();//回滚事务。

这里需要提的就是，当只想撤销事务中的部分操作时可使用SavePoint：

Ø SavePoint sp = connection.setSavepoint();

Ø connection.rollerbak(sp);connection.commit();

3) 下面用一个实例代码来展示一下：

1. package cn.itcast.jdbc;

3. import java.sql.Connection;

4. import java.sql.ResultSet;

5. import java.sql.SQLException;

6. import java.sql.Savepoint;

7. import java.sql.Statement;

8. /**

9. * 事务测试

10. */

11. public class SavePointTest {

13. public static void main(String[] args) throws SQLException {

14. testTransaction();

15. }

17. static void testTransaction() throws SQLException {

18. Connection conn = null;

19. Statement st = null;

20. ResultSet rs = null;

21. Savepoint sp = null;

22. try {

23. //获取Connection(JdbcUtils为自定义的包装类，这里不做解释)

24. conn = JdbcUtils.getConnection();

25. //开启事务

26. conn.setAutoCommit(false);

27. st = conn.createStatement();

28. //id为1的人的Money减10

29. String sql = "update user set money=money-10 where id=1";

30. st.executeUpdate(sql);

31. //********************回滚界限***************************

32. //设置回滚点(savepoint)

33. sp = conn.setSavepoint();

34. //********************回滚界限***************************

35. //id为2的人的Money减10

36. sql = "update user set money=money-10 where id=3";

37. st.executeUpdate(sql);

38. sql = "select money from user where id=2";

39. rs = st.executeQuery(sql);

40. float money = 0.0f;

41. if (rs.next()) {

42. money = rs.getFloat("money");

43. }

44. if (money > 300){

45. throw new RuntimeException("已经超过最大值！");

46. }

47. //id为2的人的Money加10

48. sql = "update user set money=money+10 where id=2";

49. st.executeUpdate(sql);

50. //提交事务

51. conn.commit();

52. } catch (RuntimeException e) {

53. if (conn != null && sp != null) {

54. //回滚事务，注意里面的参数sp即为我们上面设置的savePoint，如果回滚的话只能回滚到savePoint以下的部分

55. //上面的部分不会得到回滚

56. conn.rollback(sp);

57. conn.commit();

58. }

59. throw e;

60. } catch (SQLException e) {

61. if (conn != null)

62. conn.rollback();

63. throw e;

64. } finally {

65. //释放资源(JdbcUtils为自定义类)

66. JdbcUtils.free(rs, st, conn);

67. }

68. }

69. }

上面所有的操作(CRUD)都是在同一个数据源上的操作，无法处理跨多数据源(分布式)操作。跨多个数据源的事务就要使用JTA容器实现事务。根本思想就是“分成两阶段提交”，具体内容这里不做介绍。

1.javax.transaction.UserTransaction tx = (UserTransaction)ctx.lookup(“jndiName");

2. tx.begin();

3. //connection1 connection2 (可能来自不同的数据库)…

4. tx.commit();//tx.rollback();

隔离级别

为了应对多线程并发读取数据时出现的问题，事务有了“隔离级别”特性，多线程并发读取数据一般会引发如下三个问题：

Ø 脏读(dirtyreads)

Ø 不可重复读(non-repeatablereads)

Ø 幻读(phantomread)

下面进行简要介绍：

Ø 脏读：一个事务读取了另一个未提交的并行事务写的数据。

Ø 不可重复读：一个事务重新读取前面读取过的数据， 发现该数据已经被另一个已提交的事务修改过。

Ø 幻读：一个事务重新执行一个查询，返回一套符合查询条件的行， 发现这些行因为其他最近提交的事务而发生了改变。

2) 为了处理上面的读数据问题，java事务提供了4种隔离级别，如下：

Ø 读未提交(Read uncommitted)

Ø 读已提交(Readcommitted)

Ø 可重复读(Repeatableread)

Ø 可串行化(Serializable)

3) 4种隔离级别与上面3个问题的对应关系如下：

image

注意上面的“可能”二字。

4) 隔离级别的设定：

connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

在代码中的应用：

image

转载文章https://blog.csdn.net/dragon901/article/details/79849492