一、并发控制中锁的概念

　　锁是并发控制中最核心的概念之一，在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 TOCHANGE REPLICATION FILTERDEALLOCATE PREPAREEXECUTE STATEMENTISOLATIONLOCKPREPAREPURGE BINARY LOGSRESET MASTERRESET SLAVESAVEPOINTSET GLOBAL SQL_SLAVE_SKIP_COUNTERSET SQL_LOG_BINSTART SLAVESTART TRANSACTION #启动事务STOP SLAVEXA

　　下面将 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

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

第一百三十七期:一个简单的小案例带你理解MySQL中的事务
事务又叫做TCL,全称是transaction control language,意思是事务控制语言. 作者:Java的架构师技术栈事务又叫做TCL,全称是transaction control l ...
shell中执行某条语句失败能不能重复执行_如何理解Mysql中的事务隔离级别？
要说清楚Mysql中的事务隔离级别,我们先从事务的定义说起.事务,是一个或一组sql语句组成的一个执行单元,这个执行单元要么全部执行,要么全部不执行.整个单独单元作为一个不可分割的整体,如果单元中某条 ...
MySQL（一）:MySQL中的事务
[目录] MySQL(一):MySQL中的事务 MySQL(二):MySQL性能优化 [前言] MySQL中的事务是MySQL中重要的一部分内容:虽然之前用了很久不过这次再用的时候仍然发现自己存在一些 ...
mysql中的事务_mysql中的事务，你理解嘛？
事务又叫做TCL,全称是transaction control language,意思是事务控制语言.这篇文章还是属于我的mysql基础文章,在前面我们介绍了下面这些基础知识: 1.数据库的增查改删操 ...
MySQL中的事务相关属性以及JDBC编程
MySQL中的事务相关属性以及JDBC编程事务
mysql中不同事务隔离级别下数据的显示效果--转载
事务是一组原子性的SQL查询语句,也可以被看做一个工作单元.如果数据库引擎能够成功地对数据库应用所有的查询语句,它就会执行所有查询,如果任何一条查询语句因为崩溃或其他原因而无法执行,那么所有的语句就都 ...
mysql 事件里定义事物_聊一聊 MySQL 中的事务及其实现原理
说到数据库,那就一定会聊到事务,事务也是面试中常问的问题,我们先来一个面试场景: 面试官:"事务的四大特性是什么?" 我:"ACID,即原子性(Atomicity).隔离 ...
Mysql中的事务详解
什么是事务顾名思义,事务就是对一组事情的操作,要么把这件事办成了,要么这事儿就失败了:通俗来讲,事务就是一组sql语句的集合,要么这组sql全都执行成功,要么就全都执行失败:事务不是Mysql支持的 ...
聊一聊 MySQL 中的事务及其实现原理
说到数据库,那就一定会聊到事务,事务也是面试中常问的问题,我们先来一个面试场景: 面试官:"事务的四大特性是什么?" 我:"ACID,即原子性(Atomicity).隔离 ...

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