mysql数据库锁机制的详细介绍
前言为了保证数据的一致性，任何数据库已锁定机构，锁定机构的优点和缺点，应该直接考虑数据库系统的并发处理能力和性能，所以锁定机制已成为各类数据库的核心技术的实现。本章将使各自的锁机制最常用的两种存储引擎MySQL更详细的分析，MyISAM和InnoDB。
MySQL的锁定机制简介
数据库的锁机制是一个简单的规则，由数据库保证了数据的一致性，使各种共享资源的并发访问有序。有相应的锁紧机构，任何一种数据库，所以MySQL自然也不例外。MySQL数据库体系结构由于其自身的特点，有各种各样的数据存储引擎，每个存储引擎的应用特点也不一样，为了满足其特定的应用场景，每个存储引擎的锁定机制是特定的情景，他们面临着和优化设计，使锁紧机构的存储引擎也有较大的差异。
一般来说，MySQL存储引擎使用三种类型的锁机制：行级锁定、页级锁定和表级锁定。下面我们首先分析三种MySQL锁的特性及其各自的优缺点。
行级锁定（行级）
行级锁的最大特点是锁定对象规模小，这是最低的锁粒度达到主要的数据库管理软件目前，因为锁粒度很小，锁定资源争用的概率也最小，可以给应用尽可能多的并行处理能力可能提高一些高并发的应用系统的整体性能。
虽然它在并发处理能力的巨大优势，行级锁也带来了许多弊端，因为锁定的资源规模小，更多的事情需要每次锁和锁的释放所做的，和消费更自然。此外，排级锁也是最容易发生死锁。
表级锁定（表级）
相反，行级锁，表级锁是锁紧机构，在每一个MySQL存储引擎的最大粒度的锁紧机构的最重要的特征是，实现的逻辑是非常简单的和系统的负面影响是最小的。所以它是获得锁和释放锁很快。因为表锁锁定整个表一次，它可以避免死锁问题的好办法。
当然，大锁粒子的最大负面影响是锁定资源的概率也是最高的，造成很大的折扣。
页面级锁定（页面级）
页面级锁定是MySQL中比较独特的锁级别之一，在其他数据库管理软件中并不常见，页级锁的特性是在行级锁定和表锁定之间锁定粒度。因此，获取锁的资源成本和并发处理能力也在上述两者之间，此外，页级锁定和行级锁定也可能导致死锁。
在数据库资源锁定的过程，随着锁定的资源粒度的减小，需要相同数量的数据锁定数据存储器的数量越来越多，该算法将变得越来越复杂。然而，在锁定的资源粒度的减小，对应用程序的访问请求的可能性将随着锁等待的可能性降低，和整体系统的并发性也会增加。
在MySQL数据库中，使用表级锁主要是MyISAM，记忆，CSV和其他一些非事务性存储引擎，和行级锁主要用于InnoDB存储引擎和ndbcluster存储引擎，页级锁主锁模式BerkeleyDB存储引擎。
这种锁定机制的MySQL主要是由于其原有的历史。首先，MySQL希望设计一套锁机制是完全独立于所有存储引擎，在MySQL数据库的早期，存储引擎MySQL（MyISAM和Momery）的设计是建立在任何形式在同一时刻只允许一个单线程访问（阅读）的假设。然而，随着MySQL的不断提高，对系统的不断完善，对mysql3.23版发展，MySQL开发者不得不修正以前的假设。因为他们发现，一个线程读取一个表时另一个线程可以插上表，但只有插入的数据文件的最后一部分，我这是我们从MySQL版本的并发插入版本3.23中所说的。
并行插入出现后，MySQL开发者不得不修改锁定功能实现的系统，但只增加并发插入的支持，并没有改变整体结构。但在不久的将来，随着的BerkeleyDB存储引擎介绍，以前的锁定机制遇到了更大的挑战。因为BerkeleyDB存储引擎MyISAM和记忆并没有同时存储引擎只允许一个线程访问一个表，但这种单线程访问限制粒径减少到一个单一的页面，这又迫使MySQL开发者不得不再一次改变锁机制的实现。
由于新的存储引擎的引入，锁定机构不能满足要求，这使得MySQL知道这是不可能实现的一个完全独立的锁定机制来满足各种存储引擎的要求。如果在存储引擎的整体性能下降的存储引擎结果性能差，会严重炸毁的存储引擎供应商的积极性。这是MySQL非常不愿意看到的，因为这完全与MySQL的战略发展不一致，所以工程师不得不放弃原来的设计意图，修改锁实现机制，允许存储引擎改变MySQL本身引入的锁类型，并决定如何锁定数据。
表级锁
MySQL的表级锁定主要分为两种类型，一种是读锁，另一种是写锁。在MySQL中，四个主要队列用于维护两个锁：两个存储当前锁定的读写锁信息，另两个存储等待中的读写锁定消息。
复制代码代码如下所示：
当前读锁队列（锁定>读取）
待读锁队列（锁-> read_wait）
当前写锁队列（锁定>写入）
待写锁队列（锁-> write_wait）
目前，所有线程持有读锁相关的所有信息都可以在currentread lockqueue发现，与队列中的信息存储顺序根据获取锁的时间，等待锁资源的信息存储在pendingread lockqueue，和其他的两个队列存储锁信息也根据上述规则存储信息。
虽然这些用户MySQL锁我们表明（表锁）只有读锁和写锁两种类型，但在MySQL内部实现多达11种锁紧式，由系统枚举中的值（thr_lock_type）的定义，描述如下：
锁定类型
解释
忽略
当锁请求发生时，内部交互被使用，锁结构和队列中没有信息存储。
解锁
用于释放锁定请求的交互类型
读
常见的读锁
写
常见的写锁
read_with_shared_locks
使用InnoDB，如下：选择…lockinsharemode
read_high_priority
高优先级读锁
read_no_insert
concurentinsert锁是不允许的
write_allow_write
这种类型实际上是当存储引擎处理和锁本身，mysqld允许其他线程获得读写锁，因为即使资源冲突，存储引擎将知道如何处理它。
write_allow_read
这把锁时做DDL（之桌上…）。MySQL允许其他线程获得读锁，因为MySQL通过重建整个表来实现这个函数，然后重命名，整个过程仍然可以提供读服务。
write_concurrent_insert
锁紧方式是当ConcurentInsert正在进行。任何其他的读取锁定请求除read_no_insert不会被锁定时进行。
write_delayed
当使用insertdelayed锁类型
write_low_priority
一个低级别的锁定方法显示声明，通过建立low_priority_updat = 1
write_only
当一个锁的例外是在运行中断的closetable操作是必须在系统内，和发生在这个过程的锁的类型是write_only
读锁
在申请读取锁资源时，新的客户机请求需要满足两个条件。
1，锁定请求的资源当前没有锁定；
2。写锁等锁等待队列（pendingwrite lockqueue）没有更高优先级的。
如果你符合以上两个条件，要求将立即通过，以及相关的信息存储在currentread lockqueue，如果任何一个上述条件不满足，将被迫进入等待队列等待lockqueue pendingread释放资源。
写锁
当客户端请求写锁，MySQL首先检查是否有任何信息，同样的资源锁定在currentwrite lockqueue。
如果currentwrite lockqueue不是，再次检查pendingwrite lockqueue。如果你在pendingwrite lockqueue找到它，你也需要进入等待队列并暂停其自己的线程等待锁资源。反之，如果pendingwrite lockqueue是空的，然后再检测currentread lockqueue。如果有一把锁，它也需要进入pendingwrite lockqueue等待。当然，下面的两个特殊情况也可能遇到。
1。请求锁的类型是write_delayed；
2。请求锁的类型是write_concurrent_insert或tl_write_allow_write，和Currentreadlock是read_no_insert锁类型。
当遇到这两个特殊情况时，立即写入锁并输入当前写入锁队列。
如果有一个锁在同一资源锁定在currentwrite lockqueue时先检测启动，只能进入等待队列等待锁的释放相应的资源。
读取请求和写入等待队列中的写锁请求的优先规则主要由以下规则决定：
1。除了对read_high_priority读写锁，写锁在pendingwrite lockqueue可以阻止所有其他读锁；
2。read_high_priority读锁请求的块都写在pendingwrite lockqueue锁；
三.其他写锁定pendingwrite lockqueue低于读锁的优先级除了写写锁。
写入锁出现后currentwrite lockqueue，阻塞所有其他锁定请求在以下情况：
1。一个write_concurrent_insert可以允许在某些存储引擎允许写锁的请求
2。当锁锁定write_allow_write，所有读写锁的要求比其他write_only允许
三.当锁锁定write_allow_read，所有读取锁定请求比其他read_no_insert允许
4。当锁锁定write_delayed，所有读取锁定请求比其他read_no_insert允许
5。当锁锁定write_concurrent_insert，所有读取锁定请求比其他read_no_insert允许
随着MySQL存储引擎的不断发展，MySQL提供的锁机制已经不能满足需求。许多存储引擎已经在MySQL提供的锁定机制上构建和扩展了自己的存储引擎。
MyISAM存储引擎基本上是通过在MySQL存储引擎的最大锁定的表级锁的机制来实现，而MyISAM存储引擎并没有增加其他的锁机制本身，而是为了支持更好的性能，基于mysql原锁定机制来保障特点concurrentinsert实现相应的转变。
其他几个交易支持的存储引擎，如InnoDB、NDBCluster和BerkeleyDB存储引擎，让MySQL处理直接锁定到存储引擎本身，只有把握write_allow_write式锁紧在MySQL。
由于锁定机制MyISAM存储引擎使用的是MySQL的表级锁的实现，我们将存储引擎MyISAM存储引擎为例，论证表级锁的一些基本特性。为了使例子更直观，我将演示一个显示表锁展示写的rite_allow_read型锁的使用。
瞬间
会话
会话B
线锁基本演示
一
MySQL >设置自动提交= 0；
查询OK，0行受影响（0秒）
MySQL >设置自动提交= 0；
查询OK，0行受影响（0秒）
MySQL >更新test_innodb_lock集B = 'b1'where = 1；
查询OK，1行受影响（0秒）
匹配行：1更改：1个警告：0
更新，但不提交
二
MySQL >更新test_innodb_lock集B = 'b1'where = 1；
被阻塞，等待
三
提交；查询OK，0行受影响（0.05秒）提交
四
MySQL >更新test_innodb_lock集B = 'b1'where = 1；
查询OK，0行受影响（36.14秒）
匹配行：1更改：0个警告：0
解锁，更新正常
非索引升级到表锁定演示
五
MySQL >更新test_innodb_lock集B = '2'where B = 2000；
查询OK，1行受影响（0.02秒）
匹配行：1更改：1个警告：0
MySQL >更新test_innodb_lock集B = '3'where B = 3000；
被阻塞，等待
六
七
提交；查询OK，受影响的0行（0.10秒）
八
MySQL >更新test_innodb_lock集B = '3'where B = 3000；
查询OK，1行受影响（1分钟3.41秒）
匹配行：1更改：1个警告：0
阻塞，完成更新
间隙锁引起插入的演示
九
MySQL SELECT * FROM test_innodb_lock >；
+ + + ------ ------ |一| B | ------ ------ + + +
| 1 | B2 |
| 3 | 3 |
| 4 | 4000 |
| 5 | 5000 |
| 6 | 6000 |
| 7 | 7000 |
| 8 | 8000 |
| 9 | 9000 |
| 1 | B1 |
+ + +
9行（0秒）
MySQL >更新test_innodb_lock集B = * 100 1；
查询OK，1行受影响（0.02秒）
匹配行：1更改：1个警告：0
十
MySQL >插入test_innodb_lock值（2，'200）；
被阻塞，等待
十一
提交；
查询OK，0行受影响（0.02秒）
十二
MySQL >插入test_innodb_lock值（2，'200）；
查询OK，1行受影响（38.68秒）
阻塞释放，完全插入
使用常见索引不同数据阻塞示例
十三
MySQL >更新test_innodb_lock集B =bbbbb ' = 1和B = 'b2；
查询OK，1行受影响（0秒）
匹配行：1更改：1个警告：0
十四
MySQL >更新test_innodb_lock集B =bbbbb ' = 1和B = 'b1 '；堵塞
十五
提交；
查询OK，0行受影响（0.02秒）
十六
MySQL >更新test_innodb_lock集B =bbbbb ' = 1和B = 'b1；查询查询，1（42.89）
匹配行：1更改：1个警告：0
会话提交事务、块删除、更新完成
例如死锁
十七
在id = 11中更新t1集id = 110；
查询OK，0行受影响（0秒）
匹配行：0更改：0个警告：0
十八
在id = 21中更新T2集id = 210；
查询OK，1行受影响（0秒）
匹配行：1更改：1个警告：0
十九
在id = 21中更新T2集id = 2100；
等待sessionb释放资源被封锁
二十
在id = 11中更新t1集id = 1100；
查询行，0行受影响（0.39sec）
匹配行：0更改：0个警告：0
等待会议释放资源被封锁
两个会话同等地等待彼此的资源释放他们的资源并导致死锁。
行级锁
行级锁不是由MySQL本身实现的，而是通过其他存储引擎，如众所周知的InnoDB存储引擎，MySQL的分布式存储引擎ndbcluster。
InnoDB锁定模式与实现机制
考虑到每一个存储引擎本身都实现了行级锁，其实现也不同。InnoDB存储引擎是应用最广泛的事务性存储引擎。所以在这里我们主要分析锁定InnoDB。
总的来说，有很多的InnoDB和Oracle数据库的锁机制之间的相似性。行级锁定InnoDB也分为两种，共享锁和排它锁，以实现锁定机构锁定级和表级锁共存的过程中，我们还使用意向锁（表级锁）的概念，也有意向共享锁和互斥锁的意图两。
当一个事务需要锁定的资源，它需要，如果一个共享锁锁定的资源，它可以添加另一个共享锁，但它不能加排他锁。然而，如果我们需要锁定的资源是由一排锁住，然后我们可以等待锁释放资源，那么我们可以锁定资源，加上自己的锁。意向锁的功能是，当一个事务需要获得资源锁定，如果它满足已经锁定了本身的资源，交易可能需要添加在锁定线表合适的意向锁。如果你需要一个共享锁，你把桌上的一个意向共享锁。如果你需要一个行（或线）加上一个互斥锁，您添加的意图在他锁在桌上的第一次。意向共享锁可以同时并存，但锁的意图，同时只能有一个存在，所以我们可以说，InnoDB锁定模式可分为四种类型：S，X，是和IX.总结以上四种共存的逻辑关系通过以下表格。
共享锁（s）
X
故意共享锁（IS）
故意独占锁（九）
共享锁（s）
兼容的
冲突
兼容的
冲突
X
冲突
冲突
冲突
冲突
故意共享锁（IS）
兼容的
冲突
兼容的
兼容的
故意独占锁（九）
冲突
冲突
兼容的
兼容的
虽然InnoDB锁定机制相似，Oracle，两者的实现是完全不同的。一般的甲骨文是锁定锁定数据是信息交易规模槽物理块行锁记录需要的同一，而InnoDB被空间后的关键和最终指标在第一个指标关键点的标签信息和锁的实现记录数据。InnoDB锁实现调用下一keylocking（简希所），因为在查询执行过程中，通过全方位的查找，它锁定所有索引键在整个范围内，尽管核心价值不存在。
差距锁有致命弱点。当一个范围的关键是锁定的，甚至一些不存在的键值将被无辜，造成任何数据值的范围内锁定键锁定时插入。在某些情况下，这可能造成很大伤害的表现。Innodb的解释是组织影像阅读的出现，所以他们选择的锁锁上的差距。
除了对InnoDB的性能差距锁的负面影响，还有其他几个主要的性能危害通过索引的锁定方式：
当查询无法使用索引，InnoDB会放弃行级锁和开关表级锁的使用，从而降低并发性能。
当使用quuery索引不包含所有的过滤条件，数据检索的索引键的只是数据可查询的一部分不属于结果集的行列，但也可以被锁定，因为间隙锁是一个范围，而不是索引键；
当查询使用索引查找数据时，如果使用索引键，则访问数据在不同时将被锁定。
在InnoDB事务隔离级别的锁和死锁
来实现四的事务隔离级别，如readuncommited，readcommited、REPEATABLEREAD、和序列化，定义在ISO / ansisql92规范。同时，为了保证在交易数据的一致性，实现了多个版本的数据访问。
在第一部分中，我们已经介绍了行级锁会带来的死锁问题，和InnoDB不能例外。至于僵局的过程我们不在这里详细描述，在锁定在样品通过一个实际例子说明爱进程死锁。这里我们主要介绍如何处理死锁当线在InnoDB检测。
在事务管理和InnoDB锁定机制，有一套机制来检测死锁，将检测死锁的存在在经过短时间的僵局是在系统中产生的。当InnoDB检测到死锁发生在系统中，InnoDB会选择在两个交易产生死锁回滚由相应的判断规模较小的交易，让另一个大的交易能够顺利完成，InnoDB确定交易规模的标准是什么MySQL官方手册中也提到了这个问题。事实上，我们发现死锁后，会计算出每个交易量数据插入，更新或删除两交易确定两个交易规模，该公司变更记录的数量，更不会死锁回滚。但有一点要注意就是当一个死锁场景涉及超过InnoDB存储引擎，InnoDB不能检测到死锁。当时，我们只能通过锁定超时限制，解决这个该死的锁。此外，死锁的产生过程的一个例子将在最后的InnoDB锁的例子，本节说明。
InnoDB锁定机制的例子
复制代码代码如下所示：
MySQL >创建表test_innodb_lock（一个int（11），B varchar（16））= InnoDB引擎；
查询OK，0行受影响（0.02秒）
MySQL >创建test_innodb_lock指数test_innodb_a_ind（一）；
查询OK，0行受影响（0.05秒）
记录：0个重复：0个警告：0
MySQL >创建test_innodb_lock指数test_innodb_lock_b_ind（B）；
查询OK，11行受影响（0.01秒）
记录：11个重复：0个警告：0
时间
会话
会话B
线锁基本演示
一
MySQL >设置自动提交= 0；
查询OK，0行受影响（0秒）
MySQL >设置自动提交= 0；
查询OK，0行受影响（0秒）
MySQL >更新test_innodb_lock集B = 'b1'where = 1；
查询OK，1行受影响（0秒）
匹配行：1更改：1个警告：0
更新，但不提交
二
MySQL >更新test_innodb_lock集B = 'b1'where = 1；
被阻塞，等待
三
提交；查询OK，0行受影响（0.05秒）提交
四
MySQL >更新test_innodb_lock集B = 'b1'where = 1；
查询OK，0行受影响（36.14秒）
匹配行：1更改：0个警告：0
解锁，更新正常
非索引升级到表锁定演示
五
MySQL >更新test_innodb_lock集B = '2'where B = 2000；
查询OK，1行受影响（0.02秒）
匹配行：1更改：1个警告：0
MySQL >更新test_innodb_lock集B = '3'where B = 3000；
被阻塞，等待
六
七
提交；查询OK，受影响的0行（0.10秒）
八
MySQL >更新test_innodb_lock集B = '3'where B = 3000；
查询OK，1行受影响（1分钟3.41秒）
匹配行：1更改：1个警告：0
阻塞，完成更新
间隙锁引起插入的演示
九
MySQL SELECT * FROM test_innodb_lock >；
+ + + ------ ------ |一| B | ------ ------ + + +
| 1 | B2 |
| 3 | 3 |
| 4 | 4000 |
| 5 | 5000 |
| 6 | 6000 |
| 7 | 7000 |
| 8 | 8000 |
| 9 | 9000 |
| 1 | B1 |
+ + +
9行（0秒）
MySQL >更新test_innodb_lock集B = * 100 1；
查询OK，1行受影响（0.02秒）
匹配行：1更改：1个警告：0
十
MySQL >插入test_innodb_lock值（2，'200）；
被阻塞，等待
十一
提交；
查询OK，0行受影响（0.02秒）
十二
MySQL >插入test_innodb_lock值（2，'200）；
查询OK，1行受影响（38.68秒）
阻塞释放，完全插入
使用常见索引不同数据阻塞示例
十三
MySQL >更新test_innodb_lock集B =bbbbb ' = 1和B = 'b2；
查询OK，1行受影响（0秒）
匹配行：1更改：1个警告：0
十四
MySQL >更新test_innodb_lock集B =bbbbb ' = 1和B = 'b1 '；堵塞
十五
提交；
查询OK，0行受影响（0.02秒）
十六
MySQL >更新test_innodb_lock集B =bbbbb ' = 1和B = 'b1；查询查询，1（42.89）
匹配行：1更改：1个警告：0
会话提交事务、块删除、更新完成
例如死锁
十七
在id = 11中更新t1集id = 110；
查询OK，0行受影响（0秒）
匹配行：0更改：0个警告：0
十八
在id = 21中更新T2集id = 210；
查询OK，1行受影响（0秒）
匹配行：1更改：1个警告：0
十九
在id = 21中更新T2集id = 2100；
等待sessionb释放资源被封锁
二十
在id = 11中更新t1集id = 1100；
查询行，0行受影响（0.39sec）
匹配行：0更改：0个警告：0
等待会议释放资源被封锁
两个会话同等地等待彼此的资源释放他们的资源并导致死锁。
合理利用锁机制优化MySQL
MyISAM表锁的优化建议
对于MyISAM存储引擎，虽然表级锁中锁的实现过程中，额外的成本是低于行级锁或页级锁来实现的，并通过锁本身所消耗的资源是最少的。然而，由于对锁的粒度比较，锁定资源将比其他锁定水平更具竞争力，这将降低并发处理能力在很大程度上。
所以，当优化MyISAM存储引擎锁定的问题，最重要的是如何提高并发性。由于锁的水平是不可能改变的，我们首先要锁定时间尽可能短，并尽可能并发操作尽可能并行。
1。缩短锁定时间
缩短锁的时间，只需几句话，真的很容易说，但恐怕不是那么容易做到的。你怎样使锁的时间尽可能的短呢这样做的唯一方法是使查询执行时间尽可能短。
复杂查询被减少了多达两个，复杂查询被分割成几个小的查询分布。
尽可能建立足够有效的索引，使数据检索更加快速；
尽量保持表的存储引擎MyISAM只有必要的信息和控制字段的类型。
使用适当的机会来优化MyISAM数据文件；
2。并行操作分离
说到MyISAM的表锁，阅读和写作的相互锁定的表锁，有些人可能会认为在MyISAM存储引擎的表，他们只能完全序列化的，所以他们不能平行。你不应该忘记，还有MyISAM存储引擎的一个非常有用的功能，这是concurrentinsert特征（并发插入）。
MyISAM存储引擎有一个参数选项控制是否开启并发插入功能：concurrent_insert，可以设置为0, 1或2。三种价值的具体描述如下：
concurrent_insert = 2，无论对MyISAM存储引擎的表中的数据文件中的一部分而存在的，因为自由空间的数据删除左边是允许concurrentinsert位于数据文件尾。
concurrent_insert = 1，当有在存储引擎MyISAM表的数据文件中没有自由的空间，concurrentinsert可以从文件的末尾进行。
concurrent_insert = 0，无论对存储引擎MyISAM表的数据文件中的一部分而存在的，ConcurrentInsert是不允许的因为自由空间的数据删除左。
三.读写优先的合理使用
在这一章的各种锁分析部分，我们知道MySQL的表级锁有不同的优先级设置为读写，和优先级大于阅读优先默认。所以，如果我们能确定阅读和根据各自的系统环境的不同写作优先。如果我们的系统一个系统的读，也要优先保证查询性能，我们可以设置系统参数选择low_priority_updates = 1，将优先级设置为低优先级比阅读，可以让告诉MySQL处理读请求。当然，如果我们的系统需要保证数据写性能的，你不能把low_priority_updates参数。
在这里，我们可以使用这个属性来设置concurrent_insert参数1，即使数据被删除的可能性是非常小的，如果空间小的临时垃圾不是特别在乎的话，那concurrent_insert参数设置为2可以试试。当然，数据文件中的空间，有空间。当浪费空间时，查询时会导致更多的数据被读取。所以如果缺失量很小，是比较合适的设置concurrent_insert 1。
InnoDB行锁的优化
InnoDB存储引擎已经因为对行级锁的实现行级锁。虽然通过锁机制的实现带来的性能损失可能高于表级锁，它比MyISAM表锁定在整体的并发处理能力更好。当系统具有更高的并发性，InnoDB的整体性能将对MyISAM明显优势。然而InnoDB的行级锁，也有其自身的弱点。当我们使用它的不合理，会使整体性能InnoDB不仅高于MyISAM，甚至更糟。
我们必须做好以下工作以使InnoDB的行级锁实现合理利用的目标。
只要可能，所有的数据进行检索的索引，从而避免InnoDB因为它不能升级到表锁的索引键。
合理的设计指标，使InnoDB可以尽可能准确的关键钥匙的锁的时候，尽量减少锁定范围，避免不必要的锁定和影响其他查询执行。
尽量减少基于范围的数据检索过滤条件，避免因间隙锁造成的负面影响，并锁定不应锁定的记录；
尽可能控制事务的大小，减少锁定资源的数量并锁定时间的长度；
在业务环境的情况下，由于事务隔离级别，尽可能地使用较低级别的事务隔离以减少MySQL的额外成本。
因为行级锁和事务的InnoDB，它肯定会产生死锁。下面是一些常用的减少死锁的概率。
小编建议，读者可以根据自己的特点尝试：一）类似的业务模式，尽可能按照相同的访问权限才能访问，以防止死锁；b）在同一事务中，尽可能的锁定时间的所有资源，减少死锁的概率；C）为方便业务死锁，可以尝试升级锁粒度、表级锁定减少死锁的概率；
系统锁定争用查询。对于两个锁级别，MySQL中有两组特殊的状态变量，它们记录系统内部锁资源争用情况。让我们先看看。
表级锁定争用状态变量的MySQL实现：
复制代码代码如下所示：
MySQL >显示状态like'table %；
+ + + ----------------------- ------- | variable_name |价值| ----------------------- ------- + + +
| table_locks_immediate | 100 |
| table_locks_waited | 0 |
----------------------- ------- + + +
这里有两个状态变量记录MySQL中的内部表级锁定，这两个变量如下所示：
table_locks_immediate：次数产生表级锁；
table_locks_waited：的表级锁争用等待的次数；
两状态值都是从系统的启动记录，以及相应的事件的数量是1。如果table_locks_waited状态值是比较高的，我们可以看到，表级锁冲突更为严重，所以我们需要进一步分析为什么会出现更多的资源锁定。
行级锁使用InnoDB，该系统是由一组状态变量更详细的记录，如下：
复制代码代码如下所示：
MySQL > showstatuslike'innodb_row_lock %；
+ + + ------------------------------- -------- | variable_name |价值| ------------------------------- -------- + + +
| innodb_row_lock_current_waits | 0 |
| innodb_row_lock_time | 490578 |
| innodb_row_lock_time_avg | 37736 |
| innodb_row_lock_time_max | 121411 |
| innodb_row_lock_waits | 13 |
------------------------------- -------- + + +
行级锁的状态变量InnoDB不仅记录锁等待的次数，也记录锁的总时间，平均每次时间和最大时间。另外，非累积状态显示当前等待的等待数：
Innodb_row_lock_current_waits: the number that is currently waiting for lock - up;
innodb_row_lock_time：锁定时间的总长度从系统启动到现在；
innodb_row_lock_time_avg：花在每一次的平均时间；
innodb_row_lock_time_max：它需要等待最常见的时间从系统启动到现在的时间；
innodb_row_lock_waits：等待时间后，系统开始数。
这5个状态变量，最重要的是innodb_row_lock_time_avg（等待时间），innodb_row_lock_waits（总的等待时间）和innodb_row_lock_time（等待时间）。这三个项目很重要，特别是当等待时间很高，等待时间不太小时，需要分析系统中等待时间的原因，并根据分析结果制定优化方案。
此外，InnoDB的分析和使用提供了更丰富的即时状态信息，除了提供五系统的状态变量，你可以看到如下：
1。通过创建innodbmonitor打开表INNODB的监控功能：
复制代码代码如下所示：
MySQL >创建表innodb_monitor（INT）= InnoDB引擎；
查询OK，0行受影响（0.07秒）
2。然后检查细节用showinnodbstatus（因为输出太多被记录）；
可能会有读者朋友问为什么要创建一个表，称为innodb_monitor第一。因为表的创作实际上是告诉InnoDB，我们将监测其状态的细节。然后，InnoDB会记录更详细的交易和锁信息到MySQL错误日志，以便我们可以进一步分析和使用后。
总结
这一章是锁定在mysqlserver的介绍开始，分析了表级锁、行级锁的广泛应用于当前MySQL锁定模式的基本实现机制，并通过MyISAM和两个典型的存储引擎InnoDB的表级使用样品存储引擎锁、行级锁定比较详细的介绍和分析，然后，通过对两种锁定方法特点的分析，给出了相应的优化建议和对策。最后，我们学会了如何获取当前资源的争夺在系统中的mysqlserver各种锁。希望本章的内容将有助于读者朋友了解MySQL锁定机制。