关于MySQL三大并发事务的问题以及解决方法

已于 2024-05-23 08:06:46 修改
阅读量943 收藏 8
点赞数 31
分类专栏： MySQL 文章标签： mysql 数据库
于 2024-05-19 23:52:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77975940/article/details/139050156
版权

我们在利用MySQL进行事务的操作时，不同客户端对一个事务进行并发操作时，难免会出现事务的冲突问题。MySQL提供了解决这些问题的代码，即隔离等级。接下来让我为大家讲解这些问题的类型和隔离等级的作用。

目录

目录：

——初步认识问题以及隔离级别

---问题：

---隔离等级

---隔离级别的查询和设置

——隔离级别演示以及问题介绍

---Read uncommitted：

-脏读问题：

---Read committed：

-脏读问题的解决：

-不可重复读问题：

---Repeatable Read

-不可重复读问题的解决：

-幻读问题：

--- Serializable

-幻读问题的解决：

——初步认识问题以及隔离级别

---问题：

（1）脏读

一个事务读到另一个事务还没有提交的数据。当B事务进行更新的操作时，该操作作为事务还未提交，但影响了A事务，使A事务读到了B事务未提交的脏数据。

（2）不可重复读

一个事务先后读取同一条记录，但两次读取的数据不同，称为不可重复读这里A事务两次查询的事务不同，是因为B事务对数据进行了修改，A事务在重复读取数据的时候会发现数据不同。

（3）幻读

一个事务按照条件查询数据时，没有对应的数据行，但是在插入数据时，又发现这行数据已存在，好像出现了幻影。

---隔离等级

（1）Read uncommitted：

 脏并发事务读x 不可重复读√ 幻读√(性能最高，数据安全性最差)

（2）Read committed：

脏读x 不可重复读√ 幻读√

（3）Repeatable read

脏读x 不可重复读x 幻读√(MySQL的默认隔离等级)

（4）Serializable

脏读x 不可重复读x 幻读x(性能最底下，数据安全性最高)

---隔离级别的查询和设置

查询隔离级别：

SELECT @@TRANSACTION_ISOLATION;

设置隔离级别：

SET [SESSION | GOLBAL ] TRANSACTION LEVEL (Read uncommitted/Read committed/Repeatable/Serializable();

/*其中SESSION 表示只设置当前事务，而GOLBAL表示设置全局事务*/

——隔离级别演示以及问题介绍

这里我们打开两个命令操作符号，用 mysql -u 用户名 -p 载入数据库，分别表示用户1和用户2在同时操作一个数据集。该数据集为account，表达了用户银行的信息。具体数据如下：

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+

---Read uncommitted：

read uncommitted没有任何的隔离功能。

-脏读问题：

/*这里使用命令提示符来输入的，现在是用户A*/
mysql> set session transaction isolation level read uncommitted;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql>
mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

可见用户A采用了read uncommitted隔离模式，这个隔离模式起不到任何的隔离作用。A开启了一个事务，对数据集进行了查询，但没有结束事务

mysql> /*用户B*/
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

mysql> update account set money = money - 1000 where name = '张三';
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |     0 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

这里用户B也开启了一个事务，并且更新了数据，但并没有结束事务。

mysql> /*用户A*/
mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |     0 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

这里我们在切换到用户A的客户端，再次进行查询，发现数据变换了，出现了“脏读”现象。

---Read committed：

-脏读问题的解决：

read committed可以解决脏读问题。

mysql> /*用户A*/
mysql> set session transaction isolation level read committed;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

这里用户A进行了read committed级别的隔离，并且开启事务对account进行了查询。

mysql> /*用户B*/
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> update account set money = money - 1000 where name = '张三';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |     0 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

用户B开启了事务，并再次成功更改了数据。

mysql> /*用户A*/
mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

而这次用户A再次进行查询时，数据并没有发生变化，说明脏读问题得到了解决。

-不可重复读问题：

mysql> /*用户A*/
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

数据复原后，用户A再次开启新的事务，对account进行查询。

mysql> /*用户B*/
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> update account set money = money - 1000 where name = '张三';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> commit;
Query OK, 0 rows affected (0.00 sec)

这时，用户B再次更改了数据，并且进行了提交

mysql> /*用户A*/
mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |     0 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

当用户A在它的事务中再次查询时，出现了已经更改过的数据，这就出现了不可重复读的问题。

---Repeatable Read

Repeatable可以解决脏读，不可重复读的问题。

-不可重复读问题的解决：

mysql> /*用户A*/
mysql>  set session transaction isolation level repeatable read;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

 用户A开启了Repeatable read隔离级别

mysql> /*用户B*/
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> update account set money = money - 1000 where name = '张三';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> commit;
Query OK, 0 rows affected (0.00 sec)

 这时，用户B再次更改了数据，并且进行了提交

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | 张三 |  1000 |
|  2 | 李四 |  3000 |
+----+------+-------+
2 rows in set (0.00 sec)

 这是，用户A事务不会被B已经提交的事务数据而污染，解决了不可重复读的问题。

-幻读问题：

mysql> /*用户A*/
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account where id=3;
Empty set (0.01 sec)

开启A的事务，查询id为3的人，结果显示不存在。

mysql> /*用户B*/
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> insert into account(id,name,money) values(3,'王五',2000);
Query OK, 1 row affected (0.00 sec)

mysql> commit;
Query OK, 0 rows affected (0.01 sec)

用户B插入一条新数据，并且提交了事务。

mysql> /*用户A*/
mysql> select * from account where id=3;
Empty set (0.00 sec)

mysql> insert into account(id,name,money) values(3,'二麻子',2000);
ERROR 1062 (23000): Duplicate entry '3' for key 'account.PRIMARY'

这是用户A再次查询，还是没有数据，可当A想插入一条数据时，却出现了数据冲突的错误，就像出现幻觉一样。这就是幻读问题

--- Serializable

-幻读问题的解决：

mysql> /*用户A*/
mysql>  set session transaction isolation level serializable;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account where id=4;
Empty set (0.00 sec)

让用户A使用Serializable隔离级别，并开启事务，查询到id为4的数据不存在

mysql> /*用户B*/
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> insert into account(id,name,money) values(4,'二麻子',2000);
_

在用户B想插入一条id为4的数据时，返回并没有成功，只是光标一直在下面一行闪动。说明事务出现了堵塞，因为A事务在执行，为了避免幻读，B事务在A事务未提交事务完成时不可以插入任何数据。这就可以解决幻读的问题

伪编辑科学家
关注
  • 31
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
图文学习MySQL的事务并发问题
Mr_Police的博客
01-23 1020
大家对于MySQL的ACID估计都是耳熟能详了吧，在这笔者还是稍微解释一下吧！ ACID指的就是事务的四个特性，分别如下： 原子性(Atomicity) ：说白点就是一个动作还没完成是不能够被打断的。 一致性(Consistent) ：指的是事务开始到结束，这期间所访问的数据必须保持一致。 隔离性(Isolation) ：比如事务A正在操作，这时候事务B也要操作这行数据，那么事务B必须等到事务A结束之后才可以进行相关操作。 持久性(Durable) ：...
Mysql事务并发问题解决方案
12-14
网上看了一下解决方案: 悲观锁 直接锁行记录 这个我在本地测试,确实有效,一个事务开始没结束,第二个事务一个等待,不过会导致处于阻塞状态,因为系统并发,不敢考虑,也就是记录下这个方式. 手动模拟: 执行第一个事
MySQL：MySQL并发事务下的四大问题--脏写、脏读、不可重复读、幻读
OceanStar的博客
12-22 3367
MySQL运行时多个事务同时执行是什么场景 引入 我们一般都是通过业务系统去对数据库执行CURD操作的 通常，我们都是在业务系统里开启事务来执行增删改操作的。比如： 也就是说，业务系统是通过执行一个一个的事务，每个事务可能是一个或者多个增删查改的SQL语句。 但是问题是业务一般是多线程的，也就是基于多线程并发对MySQL数据库去执行多个事务的，如下图： 问题：每个事务里面的多个SQL语句都是如何执行的呢？ 如下图：从磁盘加载数据页到buffer pool缓存页里去，然后更新buffer poo
MySQL事务：并发事务一般有哪些问题？
最新发布
学亮编程手记
11-27 422
更新丢失（Lost Update）：当两个或多个事务选择同一行，然后基于最初选定的值更新该行时，由于每个事务都不知道其他事务的存在，就会发生丢失更新问题，最后的更新覆盖了由其他事务所做的更新。由于并发执行，其中一个事务的修改可能会覆盖另一个事务的修改，导致其中一个事务的更新丢失。更新丢失（Update Anomaly）：多个事务同时读取相同的数据，并进行独立的修改，但由于并发执行，某些事务的更新可能会覆盖其他事务的更新，导致部分更新丢失。如果未提交的事务最终回滚，读取的数据将是无效的或不一致的。
MySQL中并发事务会带来哪些问题？
xuewei_ing的博客
03-10 1722
1.脏读 一个事务在处理过程中读取了另外一个事务未提交的数据。 2. 丢失修改 在第一个事务中修改了数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。 3. 不可重复读 一个事务范围内。多次查询某个数据，却得到不同的结果。实质是违反了事务的一致性原则。 4. 幻读： 幻读是指此事务中没有查到此数据，而在修改时却影响。 隔离级别 脏读 不可重复读 幻读 READ
MySQL笔记-事务理论及并发存在的三个问题（脏读、不可重复读、幻读）演示
IT1995的博客
05-05 1251
事务定义了一个服务操作序列，由服务器保证这些操作序列在多个客户并发访问和服务器出现故障情况下的原子性。 事务是在数据库管理系统领域发展起来的，是一种对共享数据库进行并发访问或错误处理的泛型。 在数据库中操作DML（insert，update，delete，select）或DDL（创建，改变表结构）都会发生事务。 事务的4个属性：ACID：原子性、一致性、隔离性、持久性。 解决原子性的...
事务
weixin_44793182的博客
07-22 135
事务 1.什么是事务 数据库事务(Database Transaction)，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。 简单的说：事务就是将一堆SQL(通常是增删改操作)的执行绑在一起，要么都执行成功，要么都执行失败，即都执行成功才算成功，否则就会恢复到这堆SQL执行之前的状态。 2.事务的四大特性 事务的四大特性(ACID)是： (1)原子性（Atomicit...
PHP+MySQL高并发加锁事务处理问题解决方法
10-18
为了解决这个问题，我们可以利用MySQL的`FOR UPDATE`语句和事务的隔离级别。`FOR UPDATE`语句在查询时会对相关行进行锁定，直到事务结束才释放，这样可以避免其他事务在此期间对相同数据进行修改。但是，`FOR UPDATE...
MySQL-并发事务问题及解决方案.docx
10-26
MySQL并发事务处理是数据库系统中的核心问题，尤其是在高并发场景下，如何保证数据的一致性和事务的隔离性显得尤为重要。本文将深入探讨并发事务带来的三种主要问题：脏读、不可重复读和幻读，以及MySQL如何通过事务...
MySQL为什么要避免大事务以及大事务解决的方法
09-08
MySQL数据库在处理事务时，尤其是大事务，...通过上述方法，我们可以有效地避免和解决MySQL中的大事务问题，提升系统的稳定性和性能。在设计和实现数据库操作时，应始终考虑事务的大小和影响，以确保系统的高效运行。
Mysql中的事务的特性与会出现的三种并发错误
weixin_44653963的博客
09-20 636
在Mysql中存在一个名词叫做 事务。 事务的定义： 一个或一组sql语句组成一个执行单元，这个单元要么全部执行，要么全部不执行。 事务的特性： 事务具有四大特性（ACID）： 1、原子性（Atomicity）：一个事务不可再作切割，要么全部做，要么不做。 2、一致性（Consistency）：事务的执行会使得数据从一个一致的状态转变为另一个一致的状态。 3、隔离性（Isolation）：一个事务...
mysql事务的并发带来的问题
ange_123的博客
08-13 1659
mysql事务的并发带来的问题
MySQL事务并发引发的问题
m0_70299172的博客
05-03 163
MySQL是一个客户端／服务器架构的软件，对于同一个服务器来说，可以有若干个客户端与之连接，每个客户端与服务器连接上之后，就可以称之为一个会话（Session）。每个客户端都可以在自己的会话中向服务器发出请求语句，一个请求语句可能是某个事务的一部分，也就是对于服务器来说可能同时处理多个事务。在上面我们说过事务有一个称之为隔离性的特性，理论上在某个事务对某个数据进行访问时，其他事务应该进行排队，当该事务提交之后，其他事务才可以继续访问这个数据，这样的话并发事务的执行就变成了串行化执行。
MySQL事务并发可能导致的问题
weixin_45448773的博客
02-02 291
MySQL事务并发可能导致的问题
MySQL并发事务带来的问题
weixin_61090263的博客
02-13 393
事务在并发是可能引发一致性问题的各种现象。并发事务访问相同的数据的情况有三种：读-读：两个事务同事进行读取。并发事务相继读取相同的记录。读取操作本身不会对记录有任何影响，不会引起什么问题，所以这是允许这种情况发生。写-写：两个事务一起在写写-读，读-写，当一个事务在读，一个事务在写的情况。一、写-写情况在写- 写情况下会发生脏写的现象，任何一种隔离级别都不允许这种现象的发生。所以在多个未提交事务相继对一条记录进行改动时，需要让它们排队执行。这个排队的过程其实是通过为该记录加锁来实现的。
MySQL并发事务会引起的问题
weixin_45966674的博客
11-20 781
不可重复读: 事务A 查询了一次用户表 然后事务B 更改了 表单数据 然后事务B 把事务提交了 然后事务A再执行查询 查到的是更改后的数据 简单说 因为事务B中间改了数据 还提交了事务 导致 A事务 第一和第三次查到的结果不同。而且 在解决不可重复读的情况下 尽管事务B已经提交 事务A再怎么查 都是差不多的 甚至有时候 查询条件是id 那么 A查 id为1的不存在 此时 B添加一条id为1的。
Mysql的事务并发问题和解决办法
qq_48826531的博客
08-26 3170
含义：多个事务同时对数据进行修改，其中一个事务的数据被另一个事务的操作覆盖，导致丢失修改。含义：一次事务中，两次读操作中，读到的数据行数不一致。读到了新增或者读不到删除的语句。含义：一次事务中，两次读操作中，读出来的数据内容不一致。在写写环境下，MySQL会通过锁来保证并发修改的正常。含义：在事务过程中，读到了其它事务为提交的数据。解决方法：将数据库事务提升到。解决方法：将数据库事务提升到。解决方法：将数据库事务提升到。...............
MySQL锁的分类 以及并发事务下存在的问题以及问题的解决方式
CodeDoraemon的博客
05-11 485
引言 无论何时，多个查询在同一时间修改数据，就会产生并发控制的问题，为了解决并发控制可以使用锁机制来保证数据的安全性； 在 MySQL 中存在不同种类的锁，对于数据库性能调优以及选择合适的存储引擎来存储数据，了解这些锁是十分有必要的； MySQL 按照锁的粒度划分为表锁，页锁，行锁；按照锁的类型分为共享锁，排他锁，意向锁； 意向锁分为意向排他锁，意向共享锁； 上面锁的分类可以使用下面思维导图总结总体来说 MySQL 支持的锁的粒度有行锁，页锁，表锁，但是不同的存储引擎支持的粒度是不一样的； 行锁
在SQL Server或MySQL中事务并发可能带来哪些问题？
06-03
在SQL Server或MySQL中，事务并发可能会导致以下问题： 1. 脏读：当一个事务读取了另一个事务未提交的数据时，就会发生脏读。 2. 不可重复读：当一个事务在读取数据时，另一个事务对同一数据做了修改或删除，导致第一个事务读取到的数据与之前不一致，就会发生不可重复读。 3. 幻读：当一个事务在读取一批数据时，另一个事务对这批数据中的某些数据做了插入或删除操作，导致第一个事务后续读取到的数据行数发生了变化，就会发生幻读。 这些问题都是由于事务并发导致的，因此需要通过锁机制来解决。在SQL Server或MySQL中，可以使用行级锁或表级锁来控制并发访问，以避免上述问题的发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值