参考文档
https://blog.csdn.net/J080624/article/details/73435480
一、数据库事务
1.1 事务的概念
事务指一组最小的逻辑操作单元,里面有多个操作组成。组成这组操作的各个单元,要不全部成功,要不全部不成功。
如果有一个操作失败,整个操作就回滚。
它会使数据从一种状态变换到另一种状态。
例如:A——B转帐,对应于如下两条sql语句
update from account set money=money+100 where name=‘b’;
update from account set money=money-100 where name=‘a
1.2 事务的ACID特性
+++ 事务ACID特性
原子性(Atomicity)
事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
一致性(Consistency)
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
隔离性(Isolation)
事务操作是相互隔离不受影响的。
多个用户并发访问数据库时,一个用户的事务不能被其他用户的事务所
干扰,并发事务之间数据要相互隔离。
如果不考虑隔离性,会引发安全问题如下:脏读、不可重复读、幻读(虚读)。
准确地说,并非要求做到完全无干扰。数据库规定了多种事务
隔离界别,不同的隔离级别对应不用的干扰成都,隔离级别越
高,数据一致性越好,但并发行越弱。比如对于A对B进行转
账,A没把这个交易完成的时候,B是不知道A要给他转钱。
持久性(Durability)
一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中。
事务的特性:
原子性,是一个最小逻辑操作单元 !
一致性,事务过程中,数据处于一致状态。
持久性, 事务一旦提交成功,对数据的更改会反映到数据库中。
隔离性, 事务与事务之间是隔离的。
1. 事务操作过程中,会触发MySQL的锁机制。
2. InnoDB默认是行锁,但是如果在事务操作过程中,没有用到索引,那么系统会自动全表检索数据,自动升级为表锁。
行锁:只有当前行被锁住,别的用户不能操作。
表锁:整个表被锁住,别的用户不能操作。
1.3 mysql的锁机制
如果同时在两个窗口更新同一条数据呢?一个开启手动事务,一个使用默认事务:
那么不好意思,后面那个将会抛出错误:
二、数据库事务-事务操作
事务操作分为两种:自动事务(默认的),手动事务。
3.1 手动事务
3.1.1 手动事务
Start transaction; --告诉系统内以下所有操作(写)不要直接写入数据库,先存放到事务日志。
UPDATE account SET money=money-1000 WHERE NAME='小白';
UPDATE account SET money=money+1000 WHERE NAME='黑四';
COMMIT;
sql执行完毕,两个sql语句都执行成功。
>>>>>> 开启事务,但未提交,回滚
Start transaction; --告诉系统内以下所有操作(写)不要直接写入数据库,先存放到事务日志。
UPDATE account SET money=money-1000 WHERE NAME='小白';
UPDATE account SET money=money+1000 WHERE NAME='黑四';
sql执行完毕,两个sql语句都执行成功。
虽然都执行成功,但是由于开启了事务,但没有提交,所以事务回滚
>>>>>> 开启事务,提交,出现异常回滚
Start transaction; --告诉系统内以下所有操作(写)不要直接写入数据库,先存放到事务日志。
UPDATE account SET money=money-1000 WHERE NAME='小白';
异常...
UPDATE account SET money=money+1000 WHERE NAME='黑四';
COMMIT;
sql执行完毕,出现异常回滚。
3.1.2 手动事务,设置回滚点
savepoint 回滚点名字;
rollback to 回滚点名字;
--开启事务
START TRANSACTION;
update p_user set age = 10 where id = 1;
--设置回滚点
SAVEPOINT point_name;
-- 假设错误操作
update p_user set age = 11 where id = 1;
--回滚到回滚点
ROLLBACK to point_name;
--关闭事务
COMMIT;
SELECT * from p_user where id = 1;
3.2 自动事务
在MySQL中,默认的是自动事务处理,用户操作完直接同步到数据表。
自动事务:
1. 系统通过autocommit变量进行控制。mysql默认自动事务为开启状态。
2. 如果手动开启了事务,那么将使用手动事务(不再使用默认的自动事务)。
3. 如果关闭自动事务,那么需要手动提交(commit)或回滚(rollback)。
3.2.1 查看数据库自动事务状态
3.2.2 打开或关闭自动事务状态
关闭自动事务语法:
set autocommit = 0/off;
开启自动事务语法:
set autocommit = 1/on;
>>>>>> 手动开启了手动事务,那么将使用手动事务(不在使用自动事务)(默认自动事务为开启状态)
START TRANSACTION;
update p_user set age= 20 where id = 1;
select * from p_user where id =1 ;
COMMIT;
>>>>>> 如果关闭自动事务,那么需要手动提交(commit)或回滚(rollback)
update p_user set age = 10 where id = 1;
commit;
三、数据库事务-使用sql设置事务
创建事务,并提交
START TRANSACTION;
UPDATE account SET money=money-1000 WHERE NAME='小白';
UPDATE account SET money=money+1000 WHERE NAME='黑四';
COMMIT;
sql执行完毕,两个sql语句都执行成功。
创建事务,并回滚
START TRANSACTION;
UPDATE account SET money=money-1000 WHERE NAME='小白';
UPDATE account SET money=money+1000 WHERE NAME='黑四';
ROLLBACK;
sql执行完毕,两个sql都被回滚了,所以结果相当于没有执行。
创建事务,创建回滚点,回滚部分。
START TRANSACTION;
UPDATE account SET money=money-1000 WHERE NAME='小白';
SAVEPOINT sp;
UPDATE account SET money=money+1000 WHERE NAME='黑四';
ROLLBACK TO sp;
sql执行完毕,由于设置了回滚点sp。
所以第一个sql执行成功,第二个sql回滚。
四、数据库事务-事务原理
事务开启之后,所有的操作都会临时保存到事务日志里面。
事务日志只有在得到commit命令才会同步到数据表,其他任何情况都会清空(rollback,断电,断开连接等等)。
五、JDBC事务处理(JDBC关于事务的API)
当一个连接对象被创建时,默认情况下是自动提交事务。
每次执行一个 SQL 语句时,如果执行成功,就会向数据库自动提交,而不能回滚。
为了让多个 SQL 语句作为一个事务执行:
1.调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务;
2.在所有的 SQL 语句都成功执行后,调用 commit(); 方法提交事务;
3.在出现异常时,调用 rollback(); 方法回滚事务;
4. 若此时 Connection 没有被关闭, 则需要恢复其自动提交状态。
5.
|-- Connection
void setAutoCommit(boolean autoCommit) ; 设置事务是否自动提交
如果设置为false,表示手动提交事务。
void commit() ; 手动提交事务
void rollback() ; 回滚(出现异常时候,所有已经执行成功的代码需要回退到事务开始前的状态。)
Savepoint setSavepoint(String name) 设置回滚点
注意:
1.mysql默认开启隐式的事务,对已经执行成功的sql,默认提交。
例子:模拟一次转账,不使用事务。
第一个sql执行成功(不回滚),
第二个sql执行失败(回滚)。
mysql默认开启隐式性事务,即sql执行完毕,默认提交。
第一个sql执行完毕,默认提交,所以不会滚。
第二个sql执行失败,所以回滚。
@Test
public void test1() throws SQLException {
Connection conn=null;
PreparedStatement st1=null;
PreparedStatement st2=null;
//模拟转账
String sql1_zh="update account set money=money-1000 where name='小白'";
String sql1_dz="update account set money=money+1000 where name='黑四'";
try {
conn = JdbcUtil.getConn();
//第一次执行sql 小白转给小黑 转账
st1 = conn.prepareStatement(sql1_zh);
int row1 = st1.executeUpdate();
if(1==1){
throw new RuntimeException();
}
//第二次执行sql 小白转给小黑 到账
st2 = conn.prepareStatement(sql1_dz);
int row2 = st2.executeUpdate();
} catch (Exception e) {
throw new RuntimeException(e);
}finally {
JdbcUtil.close(conn, st1);
JdbcUtil.close(conn, st2);
}
}
例子:模拟一次转账,使用事务。
第一个sql执行成功(回滚),
第二个sql执行失败(回滚)。
由于在执行第一个sql前,已经手动开启事务,
事务中发生异常,则全部回滚,
所以第一个sql回滚,第二个sql也回滚。
@Test
public void test12() throws SQLException {
Connection conn=null;
PreparedStatement st1=null;
PreparedStatement st2=null;
//模拟转账
String sql1_zh="update account set money=money-1000 where name='小白'";
String sql1_dz="update account set money=money+1000 where name='黑四'";
try {
conn = JdbcUtil.getConn(); //默认开启隐式事务。
//一、手动开启事务
conn.setAutoCommit(false);
//第一次执行sql 小白转给小黑 转账
st1 = conn.prepareStatement(sql1_zh);
int row1 = st1.executeUpdate();
if(1==1){
throw new RuntimeException();
}
//第二次执行sql 小白转给小黑 到账
st2 = conn.prepareStatement(sql1_dz);
int row2 = st2.executeUpdate();
} catch (Exception e) {
//二、若发生异常,手动回滚
conn.rollback();
throw new RuntimeException(e);
}finally {
//三、手动提交事务
conn.commit();
JdbcUtil.close(conn, st1);
JdbcUtil.close(conn, st2);
}
}
例子:模拟两次转账,使用事务, 回滚到指定的代码段
第一次转账执行成功,(不回滚)
第二次转账执行失败。(回滚)
由于在执行第一次转账执行成功后设置了回滚点,
事务中发生异常后,又手动回滚到了回滚点,
所以第一次转账提交,
第二次转账失败。
@Test
public void test12() throws SQLException {
Connection conn=null;
PreparedStatement st1=null;
PreparedStatement st2=null;
PreparedStatement st3=null;
PreparedStatement st4=null;
Savepoint sp=null;
//模拟第一次转账
String sql1_zh="update account set money=money-1000 where name='小白'";
String sql1_dz="update account set money=money+1000 where name='黑四'";
//模拟第二次转账
String sql2_zh="update account set money=money-1000 where name='小白'";
String sql2_dz="update account set money=money+1000 where name='黑四'";
try {
conn = JdbcUtil.getConn(); //默认开启隐式事务。
//一、手动开启事务
conn.setAutoCommit(false);
//第一次转账
st1 = conn.prepareStatement(sql1_zh);
st1.executeUpdate();
st2 = conn.prepareStatement(sql1_dz);
st2.executeUpdate();
//四、设置回滚点
sp = conn.setSavepoint();
if(1==1){
throw new RuntimeException();
}
//第二次转账
st3 = conn.prepareStatement(sql2_zh);
st3.executeUpdate();
st4 = conn.prepareStatement(sql2_dz);
st4.executeUpdate();
} catch (Exception e) {
//二、若发生异常,手动回滚,回滚到某个点
conn.rollback(sp);
throw new RuntimeException(e);
}finally {
//三、手动提交事务
conn.commit();
JdbcUtil.close(conn, st1);
JdbcUtil.close(conn, st2);
}
}
五、事务的隔离级别(事务的隔离性)
对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采
取必要的隔离机制, 就会导致各种并发问题:
脏读: 对于两个事物 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段. 之后, 若 T2 回滚, T1读取的内容就是临时且无效的。
不可重复读: 对于两个事物 T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段. 之后, T1再次读取同一个字段, 值就不同了。
幻读: 对于两个事物 T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行. 之后, 如果 T1 再次读取同一个表, 就会多出几行。
数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
一个事务与其他事务隔离的程度称为隔离级别. 数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。
多个线程开启各自事务操作数据库中数据时,数据库系统要负责隔离操作,以
保证各个线程在获取数据时的准确性。
5.1 如果不考虑隔离性,可能会引发如下问题
5.1.1 脏读
脏读:
一个事务读取了另一个事务改写但还未提交的数据,如果这些数据被回滚,则读到的数据是无效的。
这是非常危险的,假设A向B转帐100元,对应sql语句如下所示
1.update account set money=money-100 while name=‘a’;
2.update account set money=money+100 while name=‘b’;
当第1条sql执行完,第2条还没执行(A未提交时),如果此时B查询自己的
帐户,就会发现自己多了100元钱。如果A等B走后再回滚,B就会损失100元。
5.1.2 不可重复读
不可重复读:
在一个事务内读取表中的同一数据,多次读取结果不同。
在同一事务中,多次读取同一数据返回的结果有所不同,读到了之前的数据
后又读到了其他事务已经提交的更新的数据。
例如:
在事务A中,读取到张三的工资为5000,操作没有完成,事务还没提交。
与此同时,
事务B把张三的工资改为8000,并提交了事务。
随后,
在事务A中,再次读取张三的工资,此时工资变为8000。在一个事务中前后两次读取的结果并不致,导致了不可重复读。
很多人认为这种情况就对了,无须困惑,当然是后面的为准。我们可以考虑这样一种
情况,比如银行程序需要将查询结果分别输出到电脑屏幕和写到文件中,结果在一个
事务中针对输出的目的地,进行的两次查询不一致,导致文件和屏幕中的结果不一
致,银行工作人员就不知道以哪个为准了。
和脏读的区别是:脏读是读取前一事务未提交的脏数据,不可重复读是重新读取了
前一事务已提交的数据。
5.1.3 虚读(幻读)
虚读(幻读)
是指在一个事务内读取到了别的事务插入的数据,导致前后读取不一致。
如丙存款100元未提交,这时银行做报表统计account表中所有用户的总额
为500元,然后丙提交了,这时银行再统计发现帐户为600元了,造成虚读同样
会使银行不知所措,到底以哪个为准。
5.1.4 第一类丢失更新
A事务撤销时,把已经提交的B事务的更新数据覆盖了。例如:
这时候取款事务A撤销事务,余额恢复为1000,这就丢失了更新。
5.1.5 第二类丢失更新
A事务覆盖B事务已经提交的数据,造成B事务所做的操作丢失
5.1.6 总结 – 区别
脏读:是指在一个事务中读取到另外一个事务还未提交的数据。
不可重复读:在同一事务中,多次读取同一数据返回的结果有所不同,读到了
之前的数据后又读到了其他事务已经提交的更新的数据。
幻读:是指在一个事务内读取到了别的事务插入的数据,导致前后读取不一致。
+++ 脏读和不可重复读的区别:
脏读是读取前一事务未提交的脏数据,
不可重复读是重新读取了前一事务已提交的数据。
+++ 不可重复读和幻读的区别:
不可重复度是指读的时候 别的事务修改了数据update
幻读是指读的时候 别的事务插入或者删除了数据 insert delete
不可重复读的重点是修改:
同样的条件,你读取过的数据,再次读取出来发现值不一样了。
关注的是数据的变化。
幻读的重点在于新增或者删除:
同样的条件,第 1 次和第 2 次读出来的记录数不一样
关注的是数据条数的变化。
5.2 事务隔离性的设置语句
数据库共定义了四种隔离级别:
Serializable:可避免脏读、不可重复读、虚读情况的发生。(串行化)
Repeatable read:可避免脏读、不可重复读情况的发生。(可重复读)
Read committed:可避免脏读情况发生(读已提交)。
Read uncommitted:最低级别,以上情况均无法保证。(读未提交)
Oracle 支持的 2 种事务隔离级别:READ COMMITED(默认采用), SERIALIZABLE。
Oracle 默认的事务隔离级别为: READ COMMITED 。
MySQL 支持 4 中事务隔离级别。
MySQL 默认的事务隔离级别为: REPEATABLE READ。
5.2.1 使用sql设置事务隔离级别
查看当前会话隔离级别
select @@tx_isolation
查看系统当前隔离级别
select @@global.tx_isolation;
设置当前 mySQL 连接的隔离级别:
set transaction isolation level read committed;
设置数据库系统的全局的隔离级别:
set global transaction isolation level read committed;