java 开启一个 java开启一个事务

事务：指的是逻辑上的一组操作，组成这组操作的各个逻辑单元，要么全都成功，要么全都失败。

MYSQL命令行窗口事物常用操作有三个:

1.开启事物
start transaction ;
 2.提交事物
commit ; 3.回滚事物
rollback ;
环境准备
create table account(
    id int primary key auto_increment,
    name varchar(20),
    money double
);
 
insert into account values (null,'小张',10000);
insert into account values (null,'小凤',10000);

转账案例

1:提交事物

start transaction ; -- 开启事物

update account set money = money-1000 where name='小张'; -- 扣除小张账户的钱

update account set money = money+1000 where name='小风'; -- 给小风的账户添加钱

commit; -- 提交事物

转账成功

2:回滚事物
update account set money = 10000;  -- 恢复数据
start transaction ; -- 开启事物
update account set money = money-1000 where name='小张'; -- 扣除小张账户的钱
update account set money = money+1000 where name='小风'; -- 给小风的账户添加钱
rollback; -- 提交事物

事物回滚,转账失败!

3:事务特性

1. 原子性:事务的不可分割，组成事务的各个逻辑单元不可分割
2. 一致性：事务执行的前后，数据完整性保持一致
3. 隔离性：事务执行不应该受到其他事务的干扰
4. 持久性：事务一旦结束，数据就持久化到数据库中

【事务】隔离级别--多个事务

不考虑隔离性引发的安全性问题

隔离性：一个事务的执行，不应该受到其他事务的干扰。

如果不考虑隔离性（一个事务执行受到其他的事务的干扰），引发一些安全问题，主要体现在读取数据上：

1. 脏读：一个事务读到了另一个事务未提交的数据 ，导致多次查询结果不一致 
2. 不可重复读：一个事务读到了另一个事务已经提交的update的数据，导致多次查询结果不一致。
3. 虚读/幻读：一个事务读到了另一个事务已经提交的insert的数据，导致多次查询结果不一致。

如何解决这些安全性问题

可以通过设置事物的隔离级别解决这些安全性问题

1. read      uncommitted ：脏读，不可重复读，虚读都有可能发生
2. read      committed ：避免脏读。但是不可重复读和虚读是有可能发生 (Oracle)
3. repeatable      read ：避免脏读和不可重复读，但是虚读有可能发生  (Mysql)
4. serializable      ：避免脏读，不可重复读，虚读。

 1:【事务】演示脏读

 1.开启两个窗口A,B

 2.设置A窗口的隔离级别为read      uncommitted;

SET SESSION TRANSACTION ISOLATION LEVEL read uncommitted;

 3.在A，B两个窗口中开启事务

start transaction;

 4.在B窗口中完成转账的功能：

update account set money = money - 1000 where name= '小张';

update account set money = money + 1000 where name= '小凤';

-- 这里不提交事物

 5.在A窗口中进行查询

select * from account;

发现A窗口中已经查询到转账成功了！！！已经发生了脏读：一个事务中已经读到了另一个事务未提交的数据。

2:【事务】避免脏读

1. 开启两个窗口A,B
2. 设置A窗口的隔离级别为read      committed;

SET SESSION TRANSACTION ISOLATION LEVEL read committed;

 3.分别在两个窗口中开启事务：

start transaction;
 4.在B窗口中完成转账
update account set money = money - 1000 where name= '小张';
update account set money = money + 1000 where name= '小凤';
-- 没有提交事物
 5.在A窗口中进行查询：
select * from account;

发现这个时候没有转账成功！！！（没有查询到另一个事务未提交的数据：说明已经避免了脏读）。

6.在B窗口中提交事务
commit; 7.在A窗口查询
select * from account;

发现这次的结果已经发生了变化！！！（已经发生不可重复读：一个事务已经读到了另一个事务提交的update的数据，导致多次查询结果不一

3:【事务】避免不可重复读

1. 分别开启两个窗口A，B
2. 设置A窗口的隔离级别：repeatable      read;

SET SESSION TRANSACTION ISOLATION LEVEL repeatable read;

 3.在A，B两个窗口中开启事务:

start transaction;

 4.在B窗口完成转账

update account set money = money - 1000 where name= '小张';

update account set money = money + 1000 where name= '小凤';

-- 没有提交事物

 5.在A窗口中进行查询

select * from account;

发现没有转账成功：说明避免脏读！！！

 6.在B窗口中提交事务

commit;

 7.在A窗口中再次查询：

select * from account;

发现在一个事务中的多次查询结果是一致！！！（已经避免不可重复读）

【事务】避免虚读/幻读

1. 开启两个窗口A,B
2. 设置A窗口的隔离级别：serializable

3.  SET SESSION TRANSACTION ISOLATION LEVEL serializable;

1. 分别在两个窗口中开启事务：

2.  start transaction;

1. 在B窗口中插入一条记录

4.  insert into account values (null,'小李',10000);

1. 在A窗口中进行查询

6.  select * from account;

发现A窗口已经卡住了（说明事务不允许出现并发，A窗口需要等待B窗口事务执行完成以后，才会执行A窗口的事务。）当B窗口的事务结束（提交或者回滚），那么A窗口马上就会出现结果。

 

===========================================图解事务错误读的问题===========================================

脏读（Dirty Read）：A事务读取B事务尚未提交的数据并在此基础上操作，而B事务执行回滚，那么A读取到的数据就是脏数据。

 

时间	转账事务A	取款事务B
T1		开始事务
T2	开始事务
T3		查询账户余额为1000元
T4		取出500元余额修改为500元
T5	查询账户余额为500元（脏读）
T6		撤销事务余额恢复为1000元
T7	汇入100元把余额修改为600元
T8	提交事务

---

不可重复读（Unrepeatable Read）：事务A重新读取前面读取过的数据，发现该数据已经被另一个已提交的事务B修改过了。

时间	转账事务A	取款事务B
T1		开始事务
T2	开始事务
T3		查询账户余额为1000元
T4	查询账户余额为1000元
T5		取出100元修改余额为900元
T6		提交事务
T7	查询账户余额为900元（不可重复读）

---

幻读（Phantom Read）：事务A重新执行一个查询，返回一系列符合查询条件的行，发现其中插入了被事务B提交的行。

时间	统计金额事务A	转账事务B
T1		开始事务
T2	开始事务
T3	统计总存款为10000元
T4		新增一个存款账户存入100元
T5		提交事务
T6	再次统计总存款为10100元（幻读）