163 lines
24 KiB
HTML
163 lines
24 KiB
HTML
|
<p>SQL Server锁类型(SQL)收藏<br />1． HOLDLOCK: 在该表上保持共享锁，直到整个事务结束，而不是在语句执行完立即释放所添加的锁。 <br /> 2． NOLOCK：不添加共享锁和排它锁，当这个选项生效后，可能读到未提交读的数据或“脏数据”，这个选项仅仅应用于SELECT语句。 <br /> 3． PAGLOCK：指定添加页锁（否则通常可能添加表锁）。 <br /> 4． READCOMMITTED用与运行在提交读隔离级别的事务相同的锁语义执行扫描。默认情况下，SQL Server 2000 在此隔离级别上操作。。 <br /> 5． READPAST: 跳过已经加锁的数据行，这个选项将使事务读取数据时跳过那些已经被其他事务锁定的数据行，而不是阻塞直到其他事务释放锁，READPAST仅仅应用于READ COMMITTED隔离性级别下事务操作中的SELECT语句操作。 <br /> 6． READUNCOMMITTED：等同于NOLOCK。 <br /> 7． REPEATABLEREAD：设置事务为可重复读隔离性级别。 <br /> 8． ROWLOCK：使用行级锁，而不使用粒度更粗的页级锁和表级锁。 <br /> 9． SERIALIZABLE：用与运行在可串行读隔离级别的事务相同的锁语义执行扫描。等同于 HOLDLOCK。 <br /> 10． TABLOCK：指定使用表级锁，而不是使用行级或页面级的锁，SQL Server在该语句执行完后释放这个锁，而如果同时指定了HOLDLOCK，该锁一直保持到这个事务结束。 <br /> 11． TABLOCKX：指定在表上使用排它锁，这个锁可以阻止其他事务读或更新这个表的数据，直到这个语句或整个事务结束。 <br /> 12． UPDLOCK ：指定在读表中数据时设置更新 锁（update lock）而不是设置共享锁，该锁一直保持到这个语句或整个事务结束，使用UPDLOCK的作用是允许用户先读取数据（而且不阻塞其他用户读数据），并且保证在后来再更新数据时，这一段时间内这些数据没有被其他用户修改。<br />-----------------</p>
|
|||
|
|
<p>一. 为什么要引入锁</p>
|
|||
|
|
<p><br />当多个用户同时对数据库的并发操作时会带来以下数据不一致的问题:</p>
|
|||
|
|
<p><br />◆丢失更新</p>
|
|||
|
|
<p>A,B两个用户读同一数据并进行修改,其中一个用户的修改结果破坏了另一个修改的结果,比如订票系统</p>
|
|||
|
|
<p><br />◆脏读</p>
|
|||
|
|
<p>A用户修改了数据,随后B用户又读出该数据,但A用户因为某些原因取消了对数据的修改,数据恢复原值,此时B得到的数据就与数据库内的数据产生了不一致</p>
|
|||
|
|
<p><br />◆不可重复读</p>
|
|||
|
|
<p>A用户读取数据,随后B用户读出该数据并修改,此时A用户再读取数据时发现前后两次的值不一致</p>
|
|||
|
|
<p><br />并发控制的主要方法是封锁,锁就是在一段时间内禁止用户做某些操作以避免产生数据不一致</p>
|
|||
|
|
<p><br />二 锁的分类</p>
|
|||
|
|
<p><br />◆锁的类别有两种分法：</p>
|
|||
|
|
<p><br />1. 从数据库系统的角度来看：分为独占锁（即排它锁），共享锁和更新锁</p>
|
|||
|
|
<p><br />MS-SQL Server 使用以下资源锁模式。</p>
|
|||
|
|
<p><br />锁模式 描述</p>
|
|||
|
|
<p>共享 (S) 用于不更改或不更新数据的操作（只读操作），如 SELECT 语句。</p>
|
|||
|
|
<p>更新 (U) 用于可更新的资源中。防止当多个会话在读取、锁定以及随后可能进行的资源更新时发生常见形式的死锁。</p>
|
|||
|
|
<p>排它 (X) 用于数据修改操作，例如 INSERT、UPDATE 或 DELETE。确保不会同时同一资源进行多重更新。</p>
|
|||
|
|
<p>意向锁 用于建立锁的层次结构。意向锁的类型为：意向共享 (IS)、意向排它 (IX) 以及与意向排它共享 (SIX)。</p>
|
|||
|
|
<p>架构锁 在执行依赖于表架构的操作时使用。架构锁的类型为：架构修改 (Sch-M) 和架构稳定性 (Sch-S)。</p>
|
|||
|
|
<p>大容量更新 (BU) 向表中大容量复制数据并指定了 TABLOCK 提示时使用。</p>
|
|||
|
|
<p><br />◆共享锁</p>
|
|||
|
|
<p>共享 (S) 锁允许并发事务读取 (SELECT) 一个资源。资源上存在共享 (S) 锁时，任何其它事务都不能修改数据。一旦已经读取数据，便立即释放资源上的共享 (S) 锁，除非将事务隔离级别设置为可重复读或更高级别，或者在事务生存周期内用锁定提示保留共享 (S) 锁。</p>
|
|||
|
|
<p><br />◆更新锁</p>
|
|||
|
|
<p>更新 (U) 锁可以防止通常形式的死锁。一般更新模式由一个事务组成，此事务读取记录，获取资源（页或行）的共享 (S) 锁，然后修改行，此操作要求锁转换为排它 (X) 锁。如果两个事务获得了资源上的共享模式锁，然后试图同时更新数据，则一个事务尝试将锁转换为排它 (X) 锁。共享模式到排它锁的转换必须等待一段时间，因为一个事务的排它锁与其它事务的共享模式锁不兼容；发生锁等待。第二个事务试图获取排它 (X) 锁以进行更新。由于两个事务都要转换为排它 (X) 锁，并且每个事务都等待另一个事务释放共享模式锁，因此发生死锁。</p>
|
|||
|
|
<p><br />若要避免这种潜在的死锁问题，请使用更新 (U) 锁。一次只有一个事务可以获得资源的更新 (U) 锁。如果事务修改资源，则更新 (U) 锁转换为排它 (X) 锁。否则，锁转换为共享锁。</p>
|
|||
|
|
<p><br />◆排它锁</p>
|
|||
|
|
<p>排它 (X) 锁可以防止并发事务对资源进行访问。其它事务不能读取或修改排它 (X) 锁锁定的数据</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p><br />意向锁</p>
|
|||
|
|
<p>意向锁表示 SQL Server 需要在层次结构中的某些底层资源上获取共享 (S) 锁或排它 (X) 锁。例如，放置在表级的共享意向锁表示事务打算在表中的页或行上放置共享 (S) 锁。在表级设置意向锁可防止另一个事务随后在包含那一页的表上获取排它 (X) 锁。意向锁可以提高性能，因为 SQL Server 仅在表级检查意向锁来确定事务是否可以安全地获取该表上的锁。而无须检查表中的每行或每页上的锁以确定事务是否可以锁定整个表。</p>
|
|||
|
|
<p><br />意向锁包括意向共享 (IS)、意向排它 (IX) 以及与意向排它共享 (SIX)。</p>
|
|||
|
|
<p><br />锁模式 描述</p>
|
|||
|
|
<p>意向共享 (IS) 通过在各资源上放置 S 锁，表明事务的意向是读取层次结构中的部分（而不是全部）底层资源。</p>
|
|||
|
|
<p>意向排它 (IX) 通过在各资源上放置 X 锁，表明事务的意向是修改层次结构中的部分（而不是全部）底层资源。IX 是 IS 的超集。</p>
|
|||
|
|
<p>与意向排它共享 (SIX) 通过在各资源上放置 IX 锁，表明事务的意向是读取层次结构中的全部底层资源并修改部分（而不是全部）底层资源。允许顶层资源上的并发 IS 锁。例如，表的 SIX 锁在表上放置一个 SIX 锁（允许并发 IS 锁），在当前所修改页上放置 IX 锁（在已修改行上放置 X 锁）。虽然每个资源在一段时间内只能有一个 SIX 锁，以防止其它事务对资源进行更新，但是其它事务可以通过获取表级的 IS 锁来读取层次结构中的底层资源。</p>
|
|||
|
|
<p><br />◆独占锁：</p>
|
|||
|
|
<p>只允许进行锁定操作的程序使用，其他任何对他的操作均不会被接受。执行数据更新命令时，SQL Server会自动使用独占锁。当对象上有其他锁存在时，无法对其加独占锁。</p>
|
|||
|
|
<p>共享锁：共享锁锁定的资源可以被其他用户读取，但其他用户无法修改它，在执行Select时，SQL Server会对对象加共享锁。</p>
|
|||
|
|
<p>◆更新锁：</p>
|
|||
|
|
<p>当SQL Server准备更新数据时，它首先对数据对象作更新锁锁定，这样数据将不能被修改，但可以读取。等到SQL Server确定要进行更新数据操作时，他会自动将更新锁换为独占锁，当对象上有其他锁存在时，无法对其加更新锁。</p>
|
|||
|
|
<p><br />2. 从程序员的角度看：分为乐观锁和悲观锁。</p>
|
|||
|
|
<p>乐观锁：完全依靠数据库来管理锁的工作。</p>
|
|||
|
|
<p>悲观锁：程序员自己管理数据或对象上的锁处理。</p>
|
|||
|
|
<p><br />MS-SQLSERVER 使用锁在多个同时在数据库内执行修改的用户间实现悲观并发控制</p>
|
|||
|
|
<p><br />三 锁的粒度</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p>锁粒度是被封锁目标的大小,封锁粒度小则并发性高,但开销大,封锁粒度大则并发性低但开销小</p>
|
|||
|
|
<p><br />SQL Server支持的锁粒度可以分为为行、页、键、键范围、索引、表或数据库获取锁</p>
|
|||
|
|
<p><br />资源 描述</p>
|
|||
|
|
<p>RID 行标识符。用于单独锁定表中的一行。</p>
|
|||
|
|
<p>键 索引中的行锁。用于保护可串行事务中的键范围。</p>
|
|||
|
|
<p>页 8 千字节 (KB) 的数据页或索引页。</p>
|
|||
|
|
<p>扩展盘区 相邻的八个数据页或索引页构成的一组。</p>
|
|||
|
|
<p>表 包括所有数据和索引在内的整个表。</p>
|
|||
|
|
<p>DB 数据库。</p>
|
|||
|
|
<p><br />四 锁定时间的长短</p>
|
|||
|
|
<p><br />锁保持的时间长度为保护所请求级别上的资源所需的时间长度。</p>
|
|||
|
|
<p><br />用于保护读取操作的共享锁的保持时间取决于事务隔离级别。采用 READ COMMITTED 的默认事务隔离级别时，只在读取页的期间内控制共享锁。在扫描中，直到在扫描内的下一页上获取锁时才释放锁。如果指定 HOLDLOCK 提示或者将事务隔离级别设置为 REPEATABLE READ 或 SERIALIZABLE，则直到事务结束才释放锁。</p>
|
|||
|
|
<p><br />根据为游标设置的并发选项，游标可以获取共享模式的滚动锁以保护提取。当需要滚动锁时，直到下一次提取或关闭游标（以先发生者为准）时才释放滚动锁。但是，如果指定 HOLDLOCK，则直到事务结束才释放滚动锁。</p>
|
|||
|
|
<p><br />用于保护更新的排它锁将直到事务结束才释放。</p>
|
|||
|
|
<p>如果一个连接试图获取一个锁，而该锁与另一个连接所控制的锁冲突，则试图获取锁的连接将一直阻塞到：</p>
|
|||
|
|
<p><br />将冲突锁释放而且连接获取了所请求的锁。</p>
|
|||
|
|
<p><br />连接的超时间隔已到期。默认情况下没有超时间隔，但是一些应用程序设置超时间隔以防止无限期等待</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p><br />五 SQL Server 中锁的自定义</p>
|
|||
|
|
<p><br />◆处理死锁和设置死锁优先级</p>
|
|||
|
|
<p><br />死锁就是多个用户申请不同封锁,由于申请者均拥有一部分封锁权而又等待其他用户拥有的部分封锁而引起的无休止的等待</p>
|
|||
|
|
<p><br />可以使用SET DEADLOCK_PRIORITY控制在发生死锁情况时会话的反应方式。如果两个进程都锁定数据，并且直到其它进程释放自己的锁时，每个进程才能释放自己的锁，即发生死锁情况。</p>
|
|||
|
|
<p><br />◆2 处理超时和设置锁超时持续时间。</p>
|
|||
|
|
<p><br />@@LOCK_TIMEOUT 返回当前会话的当前锁超时设置，单位为毫秒</p>
|
|||
|
|
<p><br />SET LOCK_TIMEOUT 设置允许应用程序设置语句等待阻塞资源的最长时间。当语句等待的时间大于 LOCK_TIMEOUT 设置时，系统将自动取消阻塞的语句，并给应用程序返回"已超过了锁请求超时时段"的 1222 号错误信息</p>
|
|||
|
|
<p><br />示例</p>
|
|||
|
|
<p>下例将锁超时期限设置为 1,800 毫秒。</p>
|
|||
|
|
<p>SET LOCK_TIMEOUT 1800</p>
|
|||
|
|
<p><br />◆设置事务隔离级别。</p>
|
|||
|
|
<p><br />◆对 SELECT、INSERT、UPDATE 和 DELETE 语句使用表级锁定提示。</p>
|
|||
|
|
<p><br />◆配置索引的锁定粒度</p>
|
|||
|
|
<p>可以使用 sp_indexoption 系统存储过程来设置用于索引的锁定粒度</p>
|
|||
|
|
<p><br />六 查看锁的信息</p>
|
|||
|
|
<p><br />1 执行 EXEC SP_LOCK 报告有关锁的信息</p>
|
|||
|
|
<p>2 查询分析器中按Ctrl+2可以看到锁的信息</p>
|
|||
|
|
<p><br />七 使用注意事项</p>
|
|||
|
|
<p><br />如何避免死锁</p>
|
|||
|
|
<p>1 使用事务时，尽量缩短事务的逻辑处理过程，及早提交或回滚事务；</p>
|
|||
|
|
<p>2 设置死锁超时参数为合理范围，如：3分钟-10分种；超过时间，自动放弃本次操作，避免进程悬挂；</p>
|
|||
|
|
<p>3 优化程序，检查并避免死锁现象出现；</p>
|
|||
|
|
<p>4 .对所有的脚本和SP都要仔细测试，在正是版本之前。</p>
|
|||
|
|
<p>5 所有的SP都要有错误处理（通过@error）</p>
|
|||
|
|
<p>6 一般不要修改SQL SERVER事务的默认级别。不推荐强行加锁</p>
|
|||
|
|
<p><br />解决问题 如何对行 表 数据库加锁</p>
|
|||
|
|
<p><br />八 几个有关锁的问题</p>
|
|||
|
|
<p><br />1 如何锁一个表的某一行</p>
|
|||
|
|
<p><br />SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED</p>
|
|||
|
|
<p>SELECT * FROM table ROWLOCK WHERE id = 1</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p><br />2 锁定数据库的一个表</p>
|
|||
|
|
<p><br />SELECT * FROM table WITH (HOLDLOCK)</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p><br />加锁语句：</p>
|
|||
|
|
<p><br />sybase: <br />update 表 set col1=col1 where 1=0 ; <br />MSSQL: <br />select col1 from 表 (tablockx) where 1=0 ; <br />oracle: <br />LOCK TABLE 表 IN EXCLUSIVE MODE ； <br />加锁后其它人不可操作，直到加锁用户解锁，用commit或rollback解锁</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p><br />几个例子帮助大家加深印象</p>
|
|||
|
|
<p><br />设table1(A,B,C) <br />A B C <br />a1 b1 c1 <br />a2 b2 c2 <br />a3 b3 c3</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p>◆排它锁</p>
|
|||
|
|
<p>新建两个连接</p>
|
|||
|
|
<p>在第一个连接中执行以下语句</p>
|
|||
|
|
<p><br />begin tran <br />update table1 <br />set A='aa' <br />where B='b2' <br />waitfor delay '00:00:30' --等待30秒 <br />commit tran <br />在第二个连接中执行以下语句 <br />begin tran <br />select * from table1 <br />where B='b2' <br />commit tran</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p>若同时执行上述两个语句，则select查询必须等待update执行完毕才能执行即要等待30秒</p>
|
|||
|
|
<p><br />◆共享锁</p>
|
|||
|
|
<p>在第一个连接中执行以下语句</p>
|
|||
|
|
<p><br />begin tran <br />select * from table1 holdlock -holdlock人为加锁 <br />where B='b2' <br />waitfor delay '00:00:30' --等待30秒 <br />commit tran</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p>◆共享锁</p>
|
|||
|
|
<p>在第一个连接中执行以下语句</p>
|
|||
|
|
<p><br />begin tran <br />select * from table1 holdlock -holdlock人为加锁 <br />where B='b2' <br />waitfor delay '00:00:30' --等待30秒 <br />commit tran</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p>在第二个连接中执行以下语句</p>
|
|||
|
|
<p><br />begin tran <br />select A,C from table1 <br />where B='b2' <br />update table1 <br />set A='aa' <br />where B='b2' <br />commit tran</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p><br />若同时执行上述两个语句，则第二个连接中的select查询可以执行</p>
|
|||
|
|
<p>而update必须等待第一个事务释放共享锁转为排它锁后才能执行 即要等待30秒</p>
|
|||
|
|
<p>◆死锁</p>
|
|||
|
|
<p><br />增设table2(D,E) <br />D E <br />d1 e1 <br />d2 e2 <br />在第一个连接中执行以下语句 <br />begin tran <br />update table1 <br />set A='aa' <br />where B='b2' <br />waitfor delay '00:00:30' <br />update table2 <br />set D='d5' <br />where E='e1' <br />commit tran</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p>在第二个连接中执行以下语句</p>
|
|||
|
|
<p><br />begin tran <br />update table2 <br />set D='d5' <br />where E='e1' <br />waitfor delay '00:00:10' <br />update table1 <br />set A='aa' <br />where B='b2' <br />commit tran</p>
|
|||
|
|
<p> </p>
|
|||
|
|
<p>同时执行，系统会检测出死锁，并中止进程</p>
|
|||
|
|
<p><br />补充一点:</p>
|
|||
|
|
<p>SQL Server2000支持的表级锁定提示</p>
|
|||
|
|
<p><br />HOLDLOCK 持有共享锁，直到整个事务完成，应该在被锁对象不需要时立即释放，等于SERIALIZABLE事务隔离级别</p>
|
|||
|
|
<p><br />NOLOCK 语句执行时不发出共享锁，允许脏读 ，等于 READ UNCOMMITTED事务隔离级别</p>
|
|||
|
|
<p><br />PAGLOCK 在使用一个表锁的地方用多个页锁</p>
|
|||
|
|
<p><br />READPAST 让SQL Server跳过任何锁定行，执行事务，适用于READ UNCOMMITTED事务隔离级别只跳过RID锁，不跳过页，区域和表锁</p>
|
|||
|
|
<p><br />ROWLOCK 强制使用行锁</p>
|
|||
|
|
<p><br />TABLOCKX 强制使用独占表级锁，这个锁在事务期间阻止任何其他事务使用这个表</p>
|
|||
|
|
<p><br />UPLOCK 强制在读表时使用更新而不用共享锁</p>
|
|||
|
|
<p><br />应用程序锁:</p>
|
|||
|
|
<p>应用程序锁就是客户端代码生成的锁，而不是sql server本身生成的锁</p>
|
|||
|
|
<p><br />处理应用程序锁的两个过程</p>
|
|||
|
|
<p><br />sp_getapplock 锁定应用程序资源</p>
|
|||
|
|
<p><br />sp_releaseapplock 为应用程序资源解锁</p>
|
|||
|
|
<p><br />注意: 锁定数据库的一个表的区别</p>
|
|||
|
|
<p><br />SELECT * FROM table WITH (HOLDLOCK) 其他事务可以读取表，但不能更新删除</p>
|
|||
|
|
<p><br />SELECT * FROM table WITH (TABLOCKX) 其他事务不能读取表,更新和删除</p>
|
|||
|
|
<p>交读事务使用行版本控制。 <br />使用快照隔离。<br />使用绑定连接。<br />-----------------------------<br />分析及解决SQLServer死锁问题（续） <br />上文中，我们解决了那个场景的死锁问题。这次，我们分析一下，为什么会死锁呢？再回顾一下两个sp的写法：<br /> CREATE PROC p1 @p1 int AS <br /> SELECT c2, c3 FROM t1 WHERE c2 BETWEEN @p1 AND @p1+1<br /> GO<br /> CREATE PROC p2 @p1 int AS<br /> UPDATE t1 SET c2 = c2+1 WHERE c1 = @p1<br /> UPDATE t1 SET c2 = c2-1 WHERE c1 = @p1<br /> GO</p>
|
|||
|
|
<p> 很奇怪吧！p1没有insert，没有delete，没有update，只是一个select，p2才是update。这个和我们前面说过的，trans1里面updata A，update B；trans2里面upate B，update A，根本不贴边啊！<br /> 那么，什么导致了死锁？</p>
|
|||
|
|
<p> 需要从事件日志中，看sql的死锁信息：<br /> Spid X is running this query (line 2 of proc [p1], inputbuffer “… EXEC p1 4 …”): <br /> SELECT c2, c3 FROM t1 WHERE c2 BETWEEN @p1 AND @p1+1<br /> Spid Y is running this query (line 2 of proc [p2], inputbuffer “EXEC p2 4”): <br /> UPDATE t1 SET c2 = c2+1 WHERE c1 = @p1<br /> <br /> The SELECT is waiting for a Shared KEY lock on index t1.cidx. The UPDATE holds a conflicting X lock. <br /> The UPDATE is waiting for an eXclusive KEY lock on index t1.idx1. The SELECT holds a conflicting S lock.</p>
|
|||
|
|
<p> 首先，我们看看p1的执行计划。怎么看呢？可以执行set statistics profile on，这句就可以了。下面是p1的执行计划<br /> SELECT c2, c3 FROM t1 WHERE c2 BETWEEN @p1 AND @p1+1<br /> |--Nested Loops(Inner Join, OUTER REFERENCES:([Uniq1002], [t1].[c1]))<br /> |--Index Seek(OBJECT:([t1].[idx1]), SEEK:([t1].[c2] >= [@p1] AND [t1].[c2] <= [@p1]+(1)) ORDERED FORWARD)<br /> |--Clustered Index Seek(OBJECT:([t1].[cidx]), SEEK:([t1].[c1]=[t1].[c1] AND [Uniq1002]=[Uniq1002]) LOOKUP ORDERED FORWARD)</p>
|
|||
|
|
<p> 我们看到了一个nested loops，第一行，利用索引t1.c2来进行seek，seek出来的那个rowid，在第二行中，用来通过聚集索引来查找整行的数据。这是什么？就是bookmark lookup啊！为什么？因为我们需要的c2、c3不能完全的被索引t1.c1带出来，所以需要书签查找。<br /> 好，我们接着看p2的执行计划。<br /> UPDATE t1 SET c2 = c2+1 WHERE c1 = @p1<br /> |--Clustered Index Update(OBJECT:([t1].[cidx]), OBJECT:([t1].[idx1]), SET:([t1].[c2] = [Expr1004]))<br /> |--Compute Scalar(DEFINE:([Expr1013]=[Expr1013]))<br /> |--Compute Scalar(DEFINE:([Expr1004]=[t1].[c2]+(1), [Expr1013]=CASE WHEN CASE WHEN ...<br /> |--Top(ROWCOUNT est 0)<br /> |--Clustered Index Seek(OBJECT:([t1].[cidx]), SEEK:([t1].[c1]=[@p1]) ORDERED FORWARD)</p>
|
|||
|
|
<p> 通过聚集索引的seek找到了一行，然后开始更新。这里注意的是，update的时候，它会申请一个针对clustered index的X锁的。</p>
|
|||
|
|
<p> 实际上到这里，我们就明白了为什么update会对select产生死锁。update的时候，会申请一个针对clustered index的X锁，这样就阻塞住了（注意，不是死锁！）select里面最后的那个clustered index seek。死锁的另一半在哪里呢？注意我们的select语句，c2存在于索引idx1中，c1是一个聚集索引cidx。问题就在这里！我们在p2中更新了c2这个值，所以sqlserver会自动更新包含c2列的非聚集索引：idx1。而idx1在哪里？就在我们刚才的select语句中。而对这个索引列的更改，意味着索引集合的某个行或者某些行，需要重新排列，而重新排列，需要一个X锁。<br /> SO………，问题就这样被发现了。</p>
|
|||
|
|
<p> 总结一下，就是说，某个query使用非聚集索引来select数据，那么它会在非聚集索引上持有一个S锁。当有一些select的列不在该索引上，它需要根据rowid找到对应的聚集索引的那行，然后找到其他数据。而此时，第二个的查询中，update正在聚集索引上忙乎：定位、加锁、修改等。但因为正在修改的某个列，是另外一个非聚集索引的某个列，所以此时，它需要同时更改那个非聚集索引的信息，这就需要在那个非聚集索引上，加第二个X锁。select开始等待update的X锁，update开始等待select的S锁，死锁，就这样发生鸟。</p>
|
|||
|
|
<p> 那么，为什么我们增加了一个非聚集索引，死锁就消失鸟？我们看一下，按照上文中自动增加的索引之后的执行计划：<br /> SELECT c2, c3 FROM t1 WHERE c2 BETWEEN @p1 AND @p1+1<br /> |--Index Seek(OBJECT:([deadlocktest].[dbo].[t1].[_dta_index_t1_7_2073058421__K2_K1_3]), SEEK:([deadlocktest].[dbo].[t1].[c2] >= [@p1] AND [deadlocktest].[dbo].[t1].[c2] <= [@p1]+(1)) ORDERED FORWARD)</p>
|
|||
|
|
<p> 哦，对于clustered index的需求没有了，因为增加的覆盖索引已经足够把所有的信息都select出来。就这么简单。</p>
|
|||
|
|
<p> 实际上，在sqlserver 2005中，如果用profiler来抓eventid：1222，那么会出现一个死锁的图，很直观的说。</p>
|
|||
|
|
<p> 下面的方法，有助于将死锁减至最少（详细情况，请看SQLServer联机帮助，搜索：将死锁减至最少即可。</p>
|
|||
|
|
<p>按同一顺序访问对象。 <br />避免事务中的用户交互。 <br />保持事务简短并处于一个批处理中。 <br />使用较低的隔离级别。 <br />使用基于行版本控制的隔离级别。 <br />将 READ_COMMITTED_SNAPSHOT 数据库选项设置为 ON，使得已提交读事务使用行版本控制。 <br />使用快照隔离。<br />使用绑定连接。</p>
|
|||
|
|
<p>---------------------------</p>
|
|||
|
|
<p>转自:http://blog.csdn.net/huwei2003/article/details/4047191</p>
|