事务基本概念

• 事务的特性（ACID）

  • 原子性（Atomicity）
    原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
  • 一致性（Consistency）
    事务前后数据的完整性必须保持一致。
  • 隔离性（Isolation）
    事务的隔离性是指多个用户并发访问数据库时，一个用户的事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离。
  • 持久性（Durability）
    持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

• 如果不考虑事物的隔离性会出现以下问题

  如果不考虑事务的隔离性，会出现什么问题?

  1. 脏读

     一个事务读取到另一个事务的未提交数据。

  2. 不可重复读：两次读取的数据不一致（侧重于update）

     指的是读取数据的客户端开启事务后两次读取的数据不一致。（对方数据提交前后两次不一致）

  3. 虚读(幻读) （侧重于insert）

     两次读取的数据不一致

  4. 丢失更新

     两个事务对同一条记录进行操作，后提交的事务，将先提交的事务的修改覆盖了。

• 未避免以上问题，所以数据库系统有以下四种隔离级别

  • Serializable：可避免脏读、不可重复读、虚读情况的发生。（串行化）

    最高隔离级别，一般不采用，因为在某个用于开启事务后，其他数据库无法访问该数据，会一直等待。导致效率特别低。

  • Repeatable read：可避免脏读、不可重复读情况的发生。（可重复读）不可以避免虚读

    mysql的默认级别

  • Read committed：可避免脏读情况发生（读已提交）

  • Read uncommitted：最低级别，以上情况均无法保证。(读未提交)

  • 如何解决丢失更新的问题

    解决丢失更新可以采用两种方式:

    1.悲观锁
    悲观锁 （假设丢失更新一定会发生 ） —– 利用数据库内部锁机制，管理事务
    提供的锁机制
    1.共享锁
    select * from table lock in share mode（读锁、共享锁）
    2.排它锁
    select * from table for update （写锁、排它锁）

    /*
    mysql数据库内部提供两种常用 锁机制：共享锁(读锁)和排它锁(写锁)
    允许一张数据表中数据记录，添加多个共享锁，添加共享锁记录，对于其他事务可读不可写的
    一张数据表中数据记录，只能添加一个排它锁，在添加排它锁的数据 不能再添加其他共享锁和排它锁的 ，对于其他事物可读不可写的
    */
    update语句默认添加排它锁

    2.乐观锁
    乐观锁 （假设丢失更新不会发生）——- 采用程序中添加版本字段解决丢失更新问题

    create table product (
    id int,
    name varchar(20),
    updatetime timestamp
    );
    insert into product values(1,'冰箱',null);
    update product set name='洗衣机' where id = 1;
    解决丢失更新：在数据表添加版本字段，每次修改过记录后，版本字段都会更新，如果读取是版本字段，
    与修改时版本字段不一致，说明别人进行修改过数据 （重改）

• 在数据库中查看以及设置事务的隔离级别

  • 查看事务隔离级别

    1. select @@tx_isolation 查询当前事务隔离级别
    2. /*
    3. mysql中默认的事务隔离级别是 Repeatable read.
    4. oracle 中默认的事务隔离级别是 Read committed
    5. */

  • mysql中怎样设置事务隔离级别

    1. set session transaction isolation level read committed; /*设置当前会话事务隔离级别*/
    2. set global transaction isolation level read committed; /*全局的*/

  • jdbc设置事物隔离

    1. //使用java.sql.Connection接口中提供的方法
    2. void setTransactionIsolation(int level) throws SQLException
    3. /*
    4. 参数level可以取以下值:
    5. level - 以下 Connection 常量之一：
    6. Connection.TRANSACTION_READ_UNCOMMITTED、
    7. Connection.TRANSACTION_READ_COMMITTED、
    8. Connection.TRANSACTION_REPEATABLE_READ
    9. Connection.TRANSACTION_SERIALIZABLE。
    10. （注意，不能使用 Connection.TRANSACTION_NONE，因为它指定了不受支持的事务。）
    11. */

• 在service中进行事物控制

  在实际开发中，如果service中会进行多个数据库操作，我们应该使service的执行过程为一个完整的事务，所以我们需要在service中加入事务控制。所以在Dao层需要对connection进行操作。使用ThreaddLocal可以使我们在同一线程中不经过传参也能获取到Connectio。（其工具类如下：）

  1. public class JdbcUtil {
  3. private static final String DRIVERCLASS;
  4. private static final String URL;
  5. private static final String USERNAME;
  6. private static final String PASSWORD;
  8. private static final ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
  9. static {
  10. DRIVERCLASS = ResourceBundle.getBundle("jdbc").getString("driverClass");
  11. URL = ResourceBundle.getBundle("jdbc").getString("url");
  12. USERNAME = ResourceBundle.getBundle("jdbc").getString("username");
  13. PASSWORD = ResourceBundle.getBundle("jdbc").getString("password");
  14. }
  16. static {
  17. try {
  18. // 将加载驱动操作，放置在静态代码块中.这样就保证了只加载一次.
  19. Class.forName(DRIVERCLASS);
  20. } catch (ClassNotFoundException e) {
  21. e.printStackTrace();
  22. }
  23. }
  25. public static Connection getConnection() throws SQLException {
  26. Connection con = tl.get();// 从ThreadLocal中获取Connection。第一次获取得到的是null.
  28. if (con == null) {
  29. // 2.获取连接
  30. con = DriverManager.getConnection(URL, USERNAME, PASSWORD);
  31. tl.set(con); // 将con装入到ThreadLocal中。
  32. }
  34. // tl.remove(); //解除
  35. return con;
  36. }
  38. // 关闭操作
  39. public static void closeConnection(Connection con) throws SQLException {
  40. if (con != null) {
  41. con.close();
  42. }
  43. }
  45. public static void closeStatement(Statement st) throws SQLException {
  46. if (st != null) {
  47. st.close();
  48. }
  49. }
  51. public static void closeResultSet(ResultSet rs) throws SQLException {
  52. if (rs != null) {
  53. rs.close();
  54. }
  55. }
  56. }

  在service中（主要是要最开始要开启事务，结束了要结交，失败了需要回滚）

  1. public class AccountService {
  2. public void account(String get, String send, double money) throws AccountException{
  3. AccountDaoImpl dao = new AccountDaoImpl();
  4. Connection con = null;
  6. try {
  7. con = JdbcUtils.getConnection();
  8. // 开启事务
  9. con.setAutoCommit(false);
  11. dao.accountOut( accountOut, money);
  12. dao.accountIn( accountIn, money);
  13. } catch (Exception e) {
  14. e.printStackTrace();
  15. // 出现问题，进行事务回滚
  16. if (con != null) {
  17. try {
  18. con.rollback();
  19. } catch (SQLException e1) {
  20. e1.printStackTrace();
  21. }
  22. }
  23. throw new AccountException(e.getMessage());
  24. } finally {
  25. // 事务提交
  26. // 关闭con
  27. if (con != null) {
  28. try {
  29. con.commit();
  30. con.close();
  31. } catch (SQLException e) {
  32. e.printStackTrace();
  33. }
  34. }
  35. }
  36. }
  37. }

转载于:https://www.cnblogs.com/foerver-zs/p/a3c2d80547e63809d3a3da638827214c.html