事务隔离性和锁的区别和联系

事务隔离级别是并发控制的整体解决方案，其实际上是综合利用各种类型的锁和行版本控制，来解决并发问题。

锁是数据库并发控制的内部机制，是基础。当然，数据库同时还会利用行版本控制（SQL Server 2005 及以上）来进行并发控制；在数据库内部还使用闩（latch），互斥（mutex）等机制处理内部资源（如，缓存）的并发访问。

 

对用户来说，只有当事务隔离级别无法解决一些并发问题和需求时，才有必要在语句中手动设置锁。不适当的设置锁，可能会导致严重的阻塞和死锁。建议，只有在完全了解锁机制的情况下，才可以在语句中手动设置锁，否则应该使用事务隔离级别。

http://bbs.csdn.net/topics/340190533（9 楼）

 

下面的文章通过实际操作直观看到了隔离级别以及不同隔离级别对锁的运用：

 

数据库隔离级别有四种，应用《高性能 mysql》一书中的说明：

 

然后说说修改事务隔离级别的方法：

1. 全局修改，修改 mysql.ini 配置文件，在最后加上

1#可选参数有：READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE.

2[mysqld]

3transaction-isolation=REPEATABLE-READ

这里全局默认是 REPEATABLE-READ, 其实 MySQL 本来默认也是这个级别

2. 对当前 session 修改，在登录 mysql 客户端后，执行命令：

 

要记住 mysql 有一个 autocommit 参数，默认是 on，他的作用是每一条单独的查询都是一个事务，并且自动开始，自动提交（执行完以后就自动结束了，如果你要适用 select for update，而不手动调用 start transaction，这个 for update 的行锁机制等于没用，因为行锁在自动提交后就释放了），所以事务隔离级别和锁机制即使你不显式调用 start transaction，这种机制在单独的一条查询语句中也是适用的，分析锁的运作的时候一定要注意这一点

 

再来说说锁机制：

共享锁：由读表操作加上的锁，加锁后其他用户只能获取该表或行的共享锁，不能获取排它锁，也就是说只能读不能写

排它锁：由写表操作加上的锁，加锁后其他用户不能获取该表或行的任何锁，典型是 mysql 事务中

start transaction;

select * from user where userId = 1 for update;

执行完这句以后

　　1）当其他事务想要获取共享锁，比如事务隔离级别为 SERIALIZABLE 的事务，执行

　　select * from user;

　　将会被挂起，因为 SERIALIZABLE 的 select 语句需要获取共享锁

　　2）当其他事务执行

　　select * from user where userId = 1 for update;

　　update user set userAge = 100 where userId = 1;

　　也会被挂起，因为 for update 会获取这一行数据的排它锁，需要等到前一个事务释放该排它锁才可以继续进行

 

锁的范围:

行锁: 对某行记录加上锁

表锁: 对整个表加上锁

这样组合起来就有，行级共享锁，表级共享锁，行级排他锁，表级排他锁

 

 

下面来说说不同的事务隔离级别的实例效果，例子使用 InnoDB，开启两个客户端 A，B，在 A 中修改事务隔离级别，在 B 中开启事务并修改数据，然后在 A 中的事务查看 B 的事务修改效果：

 

1.READ-UNCOMMITTED (读取未提交内容) 级别

　　1）A 修改事务级别并开始事务，对 user 表做一次查询

 

　　2) B 更新一条记录

 

　　3）此时 B 事务还未提交，A 在事务内做一次查询，发现查询结果已经改变

 

　　4）B 进行事务回滚

 

　　5）A 再做一次查询，查询结果又变回去了

 

　　6）A 表对 user 表数据进行修改

 

　　7）B 表重新开始事务后，对 user 表记录进行修改，修改被挂起，直至超时，但是对另一条数据的修改成功，说明 A 的修改对 user 表的数据行加行共享锁 (因为可以使用 select)

 

　　可以看出 READ-UNCOMMITTED 隔离级别，当两个事务同时进行时，即使事务没有提交，所做的修改也会对事务内的查询做出影响，这种级别显然很不安全。但是在表对某行进行修改时，会对该行加上行共享锁

 

2. READ-COMMITTED（读取提交内容）

　　1）设置 A 的事务隔离级别，并进入事务做一次查询

 

　　2）B 开始事务，并对记录进行修改

 

　　3）A 再对 user 表进行查询，发现记录没有受到影响

 

　　4）B 提交事务

 

　　5）A 再对 user 表查询，发现记录被修改

 

　　6）A 对 user 表进行修改

 

　　7）B 重新开始事务，并对 user 表同一条进行修改，发现修改被挂起，直到超时，但对另一条记录修改，却是成功，说明 A 的修改对 user 表加上了行共享锁 (因为可以 select)

 

　　READ-COMMITTED 事务隔离级别，只有在事务提交后，才会对另一个事务产生影响，并且在对表进行修改时，会对表数据行加上行共享锁

 

3. REPEATABLE-READ (可重读)

　　1）A 设置事务隔离级别，进入事务后查询一次

 

　　2）B 开始事务，并对 user 表进行修改

 

　　3）A 查看 user 表数据，数据未发生改变

 

　　4）B 提交事务

 

　　5）A 再进行一次查询，结果还是没有变化

 

　　6）A 提交事务后，再查看结果，结果已经更新

 

　　7）A 重新开始事务，并对 user 表进行修改

　　8）B 表重新开始事务，并对 user 表进行修改，修改被挂起，直到超时，对另一条记录修改却成功，说明 A 对表进行修改时加了行共享锁 (可以 select)

 

　　REPEATABLE-READ 事务隔离级别，当两个事务同时进行时，其中一个事务修改数据对另一个事务不会造成影响，即使修改的事务已经提交也不会对另一个事务造成影响。

　　在事务中对某条记录修改，会对记录加上行共享锁，直到事务结束才会释放。

 

4.SERIERLIZED (可串行化)

　　1）修改 A 的事务隔离级别，并作一次查询

 

　　2）B 对表进行查询，正常得出结果，可知对 user 表的查询是可以进行的

 

　　3）B 开始事务，并对记录做修改，因为 A 事务未提交，所以 B 的修改处于等待状态，等待 A 事务结束，最后超时，说明 A 在对 user 表做查询操作后，对表加上了共享锁

 

　　SERIALIZABLE 事务隔离级别最严厉，在进行查询时就会对表或行加上共享锁，其他事务对该表将只能进行读操作，而不能进行写操作。

 

——————————————————————————————————————————————————————————————————————

 

在实际业务处理中，需要很多步动作连贯完成，比如最经典的银行转账，A 给 B 转 100 元，必须要保证先从 A 账户减去 100，然后在 B 账户加 100，这个动作是不能间断的（这个例子说明了为什么需要事务，如果再引入 C，C 同时从 A 账户取钱，则可以解释为什么要对 A 账户加锁），从程序角度看，为了保证这个动作完成，诞生了事务，事务有四个特性 ACID，但事务仅仅只是一个概念，他不是具体的技术手段，那需要具体怎么做才能保证事务 ACID 四个特性呢？关系型数据库一般通过事务日志和锁的手段实现，事务日志保证了原子性、一致性，事务日志是由数据库自行完成，因此一般开发人员接触不到事务日志，大概原理，就是在进行一切实际数据操作之前，都先写好日志，如果数据库发生意外（比如断电）后，及时可以通过日志来自行恢复。锁则保证了隔离性，保证多个事务能够按照串行化的方式请求同一数据。

但现实世界是，很多操作需要并行，简单粗暴的将所有操作（增删改查）通过锁来串行化运行必然行不通，因此需要更精细化来锁定资源，从两个方面入手，第一，针对锁下手，增加锁的类型：共享锁（S）、独占锁（X），还有一个特殊的更新锁（U），还有几乎不接触的意向锁、架构锁等，针对每个锁的解释请参见《锁模式》，他们之间是否兼容的情况请看《锁兼容性》；第二，针对锁资源范围（锁粒度），共有 11 个粒度，针对每个粒度的说明，MSDN 有更详尽的资料，这里就不再粘贴，附上链接：《锁粒度和层次》。至于平时我们经常看到的乐观锁和悲观锁，可以参考 Hibernate 中的相关内容。

一般来说，实际开发中，直接操作数据库中各种锁的几率相对比较少，更多的是利用数据库提供的四个隔离级别，未提交读、已提交读、可重复读、可序列化，还有一个特殊的基于行版本的已提交读隔离级别，把它也可以归到已提交读内，基于行版本的隔离级别就是乐观锁的处理方式。那隔离级别和锁是什么关系？通俗来说，隔离级别是锁的一个整体打包解决方案，我的理解是隔离封装了锁。针对这四种隔离，他们有各自的优点和缺点，如下表：

从表来看，隔离级别从上到下依次增加，级别越低，引起的问题也就比较多，比如脏读、丢失更新等，但等级越高，也就意味着需要管理更多的锁，无法并行处理，性能方面又受损，因此，我们在设计系统时，只需要根据业务需求选择一种当下适合的隔离级别。一种隔离级别，就有一套利用锁的方案，如此设计，目的就是为了平衡性能和功能。

如何选择一种合适的隔离级别，首选需要了解脏读、丢失更新、不可重复读和幻读的引发的问题，有篇文章举得例子不错，移步：《事务之间的相互影响》，看完这篇文章中的例子，大多数人基本就明白了，下面是用自己语言总结的：

脏读：事务 A 读到事务 B 尚未提交的修改（update，Insert，Delete）记录后，事务 B 回滚了，事务 A 读取到的就是不存在的数据；

不可重复读：事务 A 第一次读取后，事务 B 进行了修改（Delete、Update），再当事务 A 读取时，发现数据在一个事务中前后不一；

幻读：和不可重复读类似，但幻读针对 Insert 操作，当事务 A 第一读取是表内有 10 行数据，此时事务 B 插入（Insert）了一条，当事务 A 再次读取时发现变成了 11 行，造成幻觉；

丢失更新：事务 A 和事务 B 拿到同一份数据 1，A 在 1 的基础上加 1 变成 2 后，此时 B 也在 1 的基础上加 2 变成 3，由于 B 提交晚，因此最终数据变成了 3，覆盖了事务 A 的操作，称为丢失更新；