JDBC 事务的ACID属性及四种隔离级别

事务的ACID属性

1.原子性(Atomicity):原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

2.一致性(Consistency):事务必须使数据库从一个一致性状态变换到另外一个一致性状态。

3.隔离性(Isolation):事务的隔离性是指一个事务的执行不能被其他事务干扰,即一个事物内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

4.持久性(Durability):持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据故障不应该对其有任何影响。

数据库的并发问题

1.脏读:对于两个事务T1,T2,T1读取了已经被T2更新但还没有被提交的字段。之后，若T2回滚，T1读取的内容就是临时且无效的。

2.不可重复读:对于两个事务T1,T2,T1读取了一个字段，然后T2更新了该字段。之后，T1再次读取同一个字段，值就不同了。

3.幻读:对于两个事务T1,T2，T1从一个表中读取了一个字段，然后T2在该表中插入了一些新的行。之后，如果T1再次读取同一个表，就会多出几行。

四种隔离级别

项目	价格
READ UNCOMMITTED（读未提交数据）	允许事务读取未被其他事务提交的变更，脏读、不可重复读和幻读的问题都会出现
READ COMMITED(读已提交数据)	只允许事务读取已经被其它事务提交的变更，可以避免脏读，但不可重复读和幻读问题仍然可能出现
REPEATABLE READ(可重复读)	确保事务可以多次从一个字段中读取相同的值，在这个事务持续期间，禁止其他事务对这个字段进行更新，可以避免脏读和不可重复读，但幻读的问题仍然存在
SERIALIZABLE(串行化)	确保事务可以从一个表中读取相同的行，在这个事务持续期间，禁止其他事务对该表执行插入，更新和删除操作，所有并发问题都可以避免，但性能十分低下

Oracle支持的2种事务隔离级别:READ COMMITED,SERIALIZABLE.ORACLE默认的事务隔离级别为:READ COMMITED。

Mysql支持4种事务隔离级别。Mysql默认的事务隔离级别为:REPEATABLE READ.

模拟脏读现象

1.获取当前的隔离级别为TRANSACTION_READ_UNCOMMITTED(读未提交数据)，则可能会发生脏读。

    @Test
    public void testTransactionSelect() throws Exception{
         Connection conn = JDBCUtils.getConnection();
         //获取当前连接的隔离级别
         System.out.println(conn.getTransactionIsolation());
         //取消自动提交数据
        conn.setAutoCommit(false);
         String sql = "select user,password,balance from user_table where user = ?";
         User user = getInstance(conn,User.class,sql,"CC");
         System.out.println(user);
    }
//输出
1
User{user='CC', password='abcd', balance=4000}

几种隔离级别:

int TRANSACTION_NONE             = 0;
int TRANSACTION_READ_UNCOMMITTED = 1;
int TRANSACTION_READ_COMMITTED   = 2;
int TRANSACTION_REPEATABLE_READ  = 4;
int TRANSACTION_SERIALIZABLE     = 8;

当更新数据user = "CC"用户的balance为5000后，在15秒之内再次查询。

    @Test
    public void testTransactionUpdate() throws Exception{
       Connection conn = JDBCUtils.getConnection();
       //取消自动提交数据
        conn.setAutoCommit(false);
       String sql = "update user_table set balance = ? where user = ?";
       update(conn,sql,5000,"CC");

       Thread.sleep(15000);
        System.out.println("修改结束");
    }
//输出
执行完毕    
    @Test
    public void testTransactionSelect() throws Exception{
         Connection conn = JDBCUtils.getConnection();
         //获取当前连接的隔离级别
         System.out.println(conn.getTransactionIsolation());
         //取消自动提交数据
        conn.setAutoCommit(false);
         String sql = "select user,password,balance from user_table where user = ?";
         User user = getInstance(conn,User.class,sql,"CC");
         System.out.println(user);
    }
//输出
    1
User{user='CC', password='abcd', balance=5000}

得到user = "CC"用户的balance为5000，15秒之后，输出修改结束，此时再次查询。得到user = "CC"用户的balance为4000。两次的数据不一致。第一次读取的数据是临时且无效的，此种现象称为脏读。数据库中的数据也为4000没变。

WX20191218-192500@2x.png

解决脏读:设置数据库的隔离级别，conn.setTransactionIsolation(Connection. TRANSACTION_READ_COMMITTED)读已提交。

    @Test
    public void testTransactionSelect() throws Exception{
         Connection conn = JDBCUtils.getConnection();
         //获取当前连接的隔离级别
         System.out.println(conn.getTransactionIsolation());
         //设置数据库的隔离级别
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
         //取消自动提交数据
        conn.setAutoCommit(false);
         String sql = "select user,password,balance from user_table where user = ?";
         User user = getInstance(conn,User.class,sql,"CC");
         System.out.println(user);
    }
//输出
1
User{user='CC', password='abcd', balance=4000}

之后update数据库user = "CC"的balance为5000，15秒之后输出修改成功。15秒之内查询balance为4000，再次查询balance仍为4000。

    @Test
    public void testTransactionUpdate() throws Exception{
       Connection conn = JDBCUtils.getConnection();
       //取消自动提交数据
        conn.setAutoCommit(false);
       String sql = "update user_table set balance = ? where user = ?";
       update(conn,sql,5000,"CC");

       Thread.sleep(15000);
        System.out.println("修改结束");
    }
//输出
执行结束
    @Test
    public void testTransactionSelect() throws Exception{
         Connection conn = JDBCUtils.getConnection();
         //获取当前连接的隔离级别
         System.out.println(conn.getTransactionIsolation());
         //设置数据库的隔离级别
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
         //取消自动提交数据
        conn.setAutoCommit(false);
         String sql = "select user,password,balance from user_table where user = ?";
         User user = getInstance(conn,User.class,sql,"CC");
         System.out.println(user);
    }
//输出
1
User{user='CC', password='abcd', balance=4000}
修改完毕
//输出
1
User{user='CC', password='abcd', balance=4000}

至此修改数据库的隔离级别为TRANSACTION_READ_COMMITTED(读已提交)解决了脏读问题。

现在整个数据库的隔离级别仍为 READ-UNCOMMITTED(读未提交)。重启MySQL恢复为默认隔离级别TRANSACTION_REPEATABLE_READ。

WX20191218-194221@2x.png
WechatIMG1294.png

    @Test
    public void testTransactionSelect() throws Exception{
         Connection conn = JDBCUtils.getConnection();
         //获取当前连接的隔离级别
         System.out.println(conn.getTransactionIsolation());
         //设置数据库的隔离级别
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
         //取消自动提交数据
        conn.setAutoCommit(false);
         String sql = "select user,password,balance from user_table where user = ?";
         User user = getInstance(conn,User.class,sql,"CC");
         System.out.println(user);
    }
//输出
4
User{user='CC', password='abcd', balance=4000}

WX20191218-194830@2x.png