MySQL中的事务及读写锁实现并发访问控制

一、并发控制中锁的概念

  锁是并发控制中最核心的概念之一,在MySQL中的锁分两大类,一种是读锁,一种是写锁,读锁也可以称为共享锁(shared lock),写锁也通常称为排它锁(exclusive lock)。

  这里先不讨论锁的具体实现,描述一下锁的概念:读锁是共享的,或者说是相互不阻塞的。多个客户在同一时刻可以同时读取一个资源,且互不干扰。写锁则是排他的,就是说一个写锁会阻塞其他的写锁和读锁,这是出于安全策略的考虑,只有这样,才能确保在给定时间里,只有一个用户能执行写入,并防止其他用户读取正在写入的同一资源。另外在一般情况下,写锁比读锁优先级高。

  MySQL中的锁有两种粒度,一种是表锁,在表级别加锁,是MySQL中最基本的锁策略,并且开销最小,这种锁的并发性能较低;另一种为行锁,在行级加锁,并发性较高。表锁与行锁没有绝对的性能强弱之分,在应用中可以根据实际场景选择,在锁粒度与数据安全之间寻求一种平衡机制。

  锁的具体实现协议大体分为两种:显式锁和隐式锁。显式锁是指根据用户需要手动去请求的锁。隐式锁则是指存储引擎自行根据需要施加的锁。显式锁的用法示例:

  例1:开启两个ssh连接同一主机,进入MySQL,在连接A上对表tbl2做读锁操作:

1 mysql> USE mysql;
2 mysql> LOCK TABLE tbl2 READ;

  在连接B上读取数据是可以的,但是写入数据不行:

1 mysql> USE mysql;
2 mysql> SELECT * FROM tbl2;
3 mysql> INSERT INTO tbl2 VALUES (1,‘tom‘); #会一直卡在这一步,不向后执行。

  当在连接1上将tbl2解锁后,就能写入数据了:

  例2: FLUSH TABLES 命令可以将整个库上锁,表示刷写所有表,把所有表在缓存中的数据全写入磁盘。在对整个数据库进行备份时可能会用到。

mysql> FLUSH TABLES WITH READ LOCK; #刷写所有表,并持有读锁;

  解锁也是用命令 UNLOCK TABLES 。

  锁是任何存储引擎都支持的并发访问控制机制,但对事务型存储引擎来讲,这种锁机制都是单语句级别的,而事务存储引擎更需要多语句的并发控制机制。以上两个例子所实现的锁都是服务器层的,和存储引擎无关。另外在生产环境中除了事务中禁用了 AUTOCOMMIT 时可以使用 LOCK TABLES 之外,其他任何时候都不要显式的执行 LOCK TABLES 。

二、事务

1.事务的概念

  事务其实就是一组原子性的SQL查询,或者说一个独立的工作单元。用一个经典的存取钱的例子可以来解释什么是事务:假设一个银行的数据库有支票(checking)和存钱(savings)两张表。现在要从用户A的支票账户中转移200元到他的存钱账户,逻辑上我们需要三个步骤:

1.检查支票账户余额大于200;

2.在支票账户中减去200;

3.在存钱账户中加上200。

上述三个步骤必须作为一个整体来操作,这个整体就可以称为事务。事务中任何一步失败都必须回滚(ROLLBACK)所有步骤。

  可以用 START TRANSACTION 语句开始一个事务,然后可以用 COMMIT 将事务提交并将修改的数据永久保存在磁盘,也可用 ROLLBACK 撤销所有修改。银行例子的SQL样本如下:

1 START TRANSACTION;
2 SELECT balance FROM checking WHERE customer_id = 12345;
3 UPDATE checking SET balance = balance - 200 WHERE customer_id = 12345;
4 UPDATE savings SET balance = balance + 200 WHERE customer_id = 12345;
5 COMMIT;

  而一个运行良好的事务处理系统,必须具备ACID特性。ACID是指原子性(atomicity)、一致性(consistency)、隔离性(isolation)和持久性(durability)。

原子性:一个事务必须被视为一个不可分割的最小工作单元,整个事务中的所有操作要么全部提交成功,要么全部失败回滚。

一致性:数据库总是从一个一致性的状态转换到另一个一致性的状态。

隔离性:通常来说,一个事务所做的修改在最终提交前,对其它事务是不可见的。例如在前面的例子中,当第二条语句执行完,第三条语句还未开始时,另一个账户的汇款事务也开始执行,则其看到的账户状态是存取事务运行前的状态。这就涉及到了隔离级别,将在后面来介绍。

持久性:一旦事务提交,则所有修改就永久保存在数据库的磁盘中。

1.事务日志

  要保持事务的原子性,需要依靠事务日志。在一个事务运行到一半发生错误时,事务需要根据事务日志的操作记录来回滚至原来的状态。在事务运行中,事务执行修改的需求是先放在事务日志中的,再对磁盘数据进行修改,事务日志中存放的是修改的操作,而不是修改数据本身。

  事务日志可以帮助提高事务的效率。写事务日志的操作是磁盘上一小块区域的顺序I/O,而不像随机I/O在磁盘的多个地方移动磁头,这就提高了存储效率。目前大多数存储引擎都是这样实现的,修改数据通常需要写两次吸盘。

  事务日志丢失会造成很大的损失,所以建议做双写。

2.事务的提交

  自动提交(AUTOCOMMIT):MySQL默认采用自动提交模式。也就是说只要不是显式的开始一个事务,则每个查询都被当作一个事务执行提交操作。设置如下:

mysql> SHOW VARIABLES LIKE ‘AUTOCOMMIT‘;
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.01 sec)

mysql> SET AUTOCOMMIT = 0; #设置为0表示OFF,当AUTOAOMMIT=0时,所有的查询都在一个事务中,直到显式的执行COMMIT或者ROLLBACK,该事物才结束。

  事务提交相关语句:

mysql> HELP TRANSACTIONS;
topics:
   CHANGE MASTER TO
   CHANGE REPLICATION FILTER
   DEALLOCATE PREPARE
   EXECUTE STATEMENT
   ISOLATION
   LOCK
   PREPARE
   PURGE BINARY LOGS
   RESET MASTER
   RESET SLAVE
   SAVEPOINT
   SET GLOBAL SQL_SLAVE_SKIP_COUNTER
   SET SQL_LOG_BIN
   START SLAVE
   START TRANSACTION #启动事务
   STOP SLAVE
   XA

  下面将 SET AUTOCOMMIT 改为OFF,用手动方式提交事务进行简单演示:MySQL默认库中创建表tbl2,插入行id=1,Name=tom

mysql> SELECT * FROM tbl2;
+------+------+
| id   | Name |
+------+------+
|    1 | tom  |
+------+------+
1 row in set (0.00 sec)
mysql> START TRANSACTION;
mysql> USE mysql;
mysql> UPDATE tbl2 SET Name=‘Tom‘ WHERE id=1; #将小写t改为大写T
mysql> SELECT * FROM tbl2;
+------+------+
| id   | Name |
+------+------+
|    1 | Tom  |
+------+------+
1 row in set (0.00 sec)
mysql> START TRANSACTION; #开始事务
mysql> USE mysql;
mysql> UPDATE tbl2 SET Name=‘Tom‘ WHERE id=1; #将小写t改为大写T
mysql> SELECT * FROM tbl2; #查看
+------+------+
| id   | Name |
+------+------+
|    1 | Tom  |
+------+------+
mysql> ROLLBACK; #回滚
mysql> SELECT * FROM tbl2; #恢复到小写t
+------+------+
| id   | Name |
+------+------+
|    1 | tom  |
+------+------+

  要注意的是,创建表操作的滚动操作只对DML语言有效。

  还可以在每个操作后用指令 SAVEPOINT 做存档:

mysql> START TRANSACTION;
mysql> SELECT * FROM tbl2;
+------+------+
| id   | Name |
+------+------+
|    1 | tom  |
+------+------+
1 row in set (0.00 sec)
mysql> INSERT INTO tbl2 VALUES (2,‘jerry‘);
mysql> SAVEPOINT first; #创建保存点1,名为first
mysql> INSERT INTO tbl2 VALUES (3,‘cat‘);
mysql> SAVEPOINT second; #创建保存点2,名为second
mysql> DELETE FROM tbl2 WHERE id=2;
mysql> SELECT * FROM tbl2;
+------+------+
| id   | Name |
+------+------+
|    1 | tom  |
|    3 | cat  |
+------+------+
2 rows in set (0.00 sec)
mysql> ROLLBACK TO second; #滚到保存点second
mysql> SELECT * FROM tbl2;
+------+-------+
| id   | Name  |
+------+-------+
|    1 | tom   |
|    2 | jerry |
|    3 | cat   |
+------+-------+
3 rows in set (0.00 sec)

  输入命令 COMMIT 后表示事务已提交,就无法再回滚了。

3.事务隔离级别

  事务的隔离级别有四种:

1.READ UNCOMMITTED(未提交读)

  在READ UNCOMMITTED级别,事务中的修改即使没有提交,对其它事务也都是可见的。即事务可读取未提交的数据,这称为脏读(Dirty Read)。这会导致很多问题,在实际应用中一般很少用到。

2.READ COMMITED(提交读)

  READ COMMITTED表示只能读取事务修改提交后的数据。此级别有时候也叫做不可重复读(nonrepeatable read),因为两次执行同样的查询,可能会得到不一样的结果。

3.REPEATABLE READ(可重复读)

  此级别解决了脏读的问题,保证了在同一个事务中多次同样记录的结果是一致的。但会带来新的问题——幻读(Phantom Read)。MySQL默认使用此级别。

4.SERIALIZABLE(可串行化)

  SERIALIZABLE是最高的隔离级别。它会强制事务串行执行,避免了幻读、脏读的问题,但是牺牲了并发性。

  示例:

mysql> SELECT @@session.tx_isolation; #查看当前事务隔离级别
+------------------------+
| @@session.tx_isolation |
+------------------------+
| REPEATABLE-READ        |
+------------------------+
1 row in set (0.00 sec)

mysql> SET @@session.tx_isolation=‘级别‘; 可设置隔离级别

下面演示幻读的情形,启动两个连接至同一MySQL,交叉启动事务:

连接1的操作:

mysql> START TRANSACTION; #启动事务
mysql> USE mysql;
mysql> SELECT * FROM tbl2;
+------+-------+
| id   | Name  |
+------+-------+
|    1 | tom   |
|    2 | jerry |
|    3 | cat   |
+------+-------+
3 rows in set (0.00 sec)
mysql> INSERT INTO tbl2 VALUES (4,‘dog‘); #插入数据
mysql> SELECT * FROM tbl2;
+------+-------+
| id   | Name  |
+------+-------+
|    1 | tom   |
|    2 | jerry |
|    3 | cat   |
|    4 | dog   |
+------+-------+
4 rows in set (0.00 sec)

同时在连接2的操作:

mysql> START TRANSACTION;
Database changed
mysql> SELECT * FROM tbl2;
+------+-------+
| id   | Name  |
+------+-------+
|    1 | tom   |
|    2 | jerry |
|    3 | cat   |
+------+-------+
3 rows in set (0.00 sec)

这时看不到插入的"4 dog"的数据,在连接1上执行 COMMIT 提交事务:

mysql> COMMIT;

在连接2上依然看不到插入的数据,但数据确实已经写入到了磁盘,这时只有在连接2上输入 COMMIT 和 ROLLBACK 才能看到修改的数据;

mysql> ROLLBACK;
mysql> SELECT * FROM tbl2;
+------+-------+
| id   | Name  |
+------+-------+
|    1 | tom   |
|    2 | jerry |
|    3 | cat   |
|    4 | dog   |
+------+-------+
4 rows in set (0.00 sec)

原文地址:https://www.cnblogs.com/readygood/p/9853797.html

时间: 2024-08-07 20:15:12

MySQL中的事务及读写锁实现并发访问控制的相关文章

漫谈MySql中的事务

最近一直在做订单类的项目,使用了事务.我们的数据库选用的是MySql,存储引擎选用innoDB,innoDB对事务有着良好的支持.这篇文章我们一起来扒一扒事务相关的知识. 为什么要有事务? 事务广泛的运用于订单系统.银行系统等多种场景.如果有以下一个场景:A用户和B用户是银行的储户.现在A要给B转账500元.那么需要做以下几件事: 1. 检查A的账户余额>500元: 2. A账户扣除500元: 3. B账户增加500元: 正常的流程走下来,A账户扣了500,B账户加了500,皆大欢喜.那如果A账

【MySQL】漫谈MySQL中的事务及其实现

最近一直在做订单类的项目,使用了事务.我们的数据库选用的是MySQL,存储引擎选用innoDB,innoDB对事务有着良好的支持.这篇文章我们一起来扒一扒事务相关的知识. 为什么要有事务? 事务广泛的运用于订单系统.银行系统等多种场景.如果有以下一个场景:A用户和B用户是银行的储户.现在A要给B转账500元.那么需要做以下几件事: 1. 检查A的账户余额>500元: 2. A账户扣除500元: 3. B账户增加500元: 正常的流程走下来,A账户扣了500,B账户加了500,皆大欢喜.那如果A账

聊一聊 MySQL 中的事务及其实现原理

原文:聊一聊 MySQL 中的事务及其实现原理 说到数据库,那就一定会聊到事务,事务也是面试中常问的问题,我们先来一个面试场景: 面试官:"事务的四大特性是什么?" 我:"ACID,即原子性(Atomicity).隔离性(Isolation).持久性(Durability).一致性(Consistency)!" 面试官:"在 MySQL 数据库的 InnoDB 引擎是怎么实现这四大特性的?" 我:"这个...这个....,还真没有了解过

十:MYSQL中的事务

前言: 因为没有多少时间和精力,目前无法深入研究数据库中的事务,比如 但是,对于事务的一些基本知识,还是需要牢牢掌握的,做到了解事务的基本常识,在实际开发中能够理解各个持久层框架对事务的处理 一:是么是事务? 下面是百度百科的结果 在开发中对于一个业务逻辑需要对数据进行的一系列CRUD操作,这一系列操作,我们可以把它称为一个事务 这样理解事务就必须了解事务四大特性:原子性 .一致性.隔离性.持久性 二:事务的四大特性--ACID 2.1:原子性 在一个事务中对数据的所有操作,属于一个单元,不可分

MySql中操作事务

假如我们有一个表,为account,其内容为: ID NAME BALANCE 1 zhangsan 1000 2 lisi 1000 什么是事务 比如支付宝转账!张三转1000块到李四的账户,这其实需要两条SQL语句: 给张三的账户减去1000元: 给李四的账户加上1000元. 如果在第一条SQL语句执行成功后,在执行第二条SQL语句之前,程序被中断了(可能地下光纤被挖掘机挖断了--确实存在的哦),那么李四的账户没有加上1000元,而张三却减去了1000元.这肯定是不行的! 你现在可能已经知道

浅谈mysql中不同事务隔离级别下数据的显示效果

事务的概念 事 务是一组原子性的SQL查询语句,也可以被看做一个工作单元.如果数据库引擎能够成功地对数据库应用所有的查询语句,它就会执行所有查询,如果任何一条查 询语句因为崩溃或其他原因而无法执行,那么所有的语句就都不会执行.也就是说,事务内的语句要么全部执行,要么一句也不执行. 事务的特性:acid,也称为事务的四个测试(原子性,一致性,隔离性,持久性) automicity:原子性,事务所引起的数据库操作,要么都完成,要么都不执行consisitency:一致性,事务执行前的总和和事务执行后

mysql中不同事务隔离级别下数据的显示效果--转载

事务是一组原子性的SQL查询语句,也可以被看做一个工作单元.如果数据库引擎能够成功地对数据库应用所有的查询语句,它就会执行所有查询,如果任何一条查询语句因为崩溃或其他原因而无法执行,那么所有的语句就都不会执行.也就是说,事务内的语句要么全部执行,要么一句也不执行. 事务的特性:acid,也称为事务的四个测试(原子性,一致性,隔离性,持久性) automicity:原子性,事务所引起的数据库操作,要么都完成,要么都不执行 consisitency:一致性,事务执行前的总和和事务执行后的总和是不变的

mysql中的事务隔离级别及可重复读读提交详细分析(mvcc多版本控制/undo log)

一.事物隔离级别 读未提交(read uncommitted)是指,一个事务还没提交时,它做的变更就能被别的事务看到.通俗理解,别人改数据的事务尚未提交,我在我的事务中也能读到. 读提交(read committed)是指,一个事务提交之后,它做的变更才会被其他事务看到.通俗理解,别人改数据的事务已经提交,我在我的事务中才能读到. 可重复读(repeatable read)是指,一个事务执行过程中看到的数据,总是跟这个事务在启动时看到的数据 是一致的.当然在可重复读隔离级别下,未提交变更对其他事

关于MYSQL中的事务

mysql中只有innodb支持事务. 事务有4个特点 1.原子性(Atomicity) 事务中包含的程序作为数据库的逻辑工作单位,它对数据库中的数据进行操作时,要么全部执行,要么都不执行. 举个例子,你给小A转账500块时.这个时候银行的数据库会将你卡里的金额减500,同时小A卡里的金额增加500.不存在你的钱被扣,小A的钱没加.或者你的钱没扣,小A的钱增加了. 2.一致性(Consistancy) 一个事务执行前和执行后,数据库都必须要处于一致性的状态. 这句话是怎么理解:就是你给小A的卡里