SQLServer Lock

1． HOLDLOCK: 在该表上保持共享锁，直到整个事务结束，而不是在语句执行完立即释放所添加的锁。    

1.  begin   tran    
2.   declare   @a   int    
3.   select   @a=a   from   tb   with(holdlock)
4.   where   a=1    
5.      
6.   waitfor   delay   '00:00:10'    
7.      
8.   select   *   from   tb    
9.   commit   tran    
10.   go    

1. --update   tb   set   a=2000  
3. INSERT INTO tb
4. VALUES(1)
6. --select   *   from   tb

执行holdlock后，INSERT INTO tb执行,事务中的select   *   from   tb    获得最新数据

holdlock
锁定匹配的行记录,未匹配到全锁

 

2． NOLOCK：不添加共享锁和排它锁，当这个选项生效后，可能读到未提交读的数据或“脏数据”，这个选项仅仅应用于SELECT语句。    
3． PAGLOCK：指定添加页锁（否则通常可能添加表锁）。  
4． READCOMMITTED用与运行在提交读隔离级别的事务相同的锁语义执行扫描。默认情况下，SQL Server 2000 在此隔离级别上操作。。  
5． READPAST: 跳过已经加锁的数据行，这个选项将使事务读取数据时跳过那些已经被其他事务锁定的数据行，而不是阻塞直到其他事务释放锁，READPAST仅仅应用于READ COMMITTED隔离性级别下事务操作中的SELECT语句操作。   
6． READUNCOMMITTED：等同于NOLOCK。    
7． REPEATABLEREAD：设置事务为可重复读隔离性级别。  
8． ROWLOCK：使用行级锁，而不使用粒度更粗的页级锁和表级锁。   

sqlserver锁定一行的最小锁是?

http://www.cnblogs.com/jll/articles/1240207.html 
9． SERIALIZABLE：用与运行在可串行读隔离级别的事务相同的锁语义执行扫描。等同于 HOLDLOCK。 
10． TABLOCK：指定使用表级锁，而不是使用行级或页面级的锁，SQL Server在该语句执行完后释放这个锁，而如果同时指定了HOLDLOCK，该锁一直保持到这个事务结束。    
11． TABLOCKX：指定在表上使用排它锁，这个锁可以阻止其他事务读或更新这个表的数据，直到这个语句或整个事务结束。  
12． UPDLOCK ：指定在读表中数据时设置更新 锁（update lock）而不是设置共享锁，该锁一直保持到这个语句或整个事务结束，使用UPDLOCK的作用是允许用户先读取数据（而且不阻塞其他用户读数据），并且保证在后来再更新数据时，这一段时间内这些数据没有被其他用户修改。  读取表时使用更新锁，而不使用共享锁，并将锁一直保留到语句或事务的结束。UPDLOCK   的优点是允许您读取数据（不阻塞其它事务）并在以后更新数据，同时确保自从上次读取数据后数据没有被更改。

1. --做一下下面的两个测试,也许对理解有帮助   
2.     
3.   --------------------------------------------   
4.   --     测试1,使用   updlock     
5.   --------------------------------------------   
6.   --a.创建这样一个测试表   
7.   create   table   tb(a   int)   
8.   insert   tb   select   1   
9.   union   all   select   2   
10.   go   
11.     
12.   --b.查询分析器中新开一个窗口,执行下面的语句   
13.   begin   tran   
14.   declare   @a   int   
15.   select   @a=a   from   tb   with(updlock)   
16.   where   a=1   
17.     
18.   waitfor   delay   '00:00:10'   
19.     
20.   select   *   from   tb   
21.   commit   tran   
22.   go   
23.     
24.   --c.再在查询分析器中新开一个窗口,执行下面的语句   
25.   update   tb   set   a=200   
26.     
27.   --结果:   c窗口中的update   会一直等待到b窗口中的事务提交后再执行   
28.   --             可以得到这个结论是因为在b窗口出结果前,c   窗口一直等待   
29.   --             而且b窗口得到的结果是a列没有被更新前的值   
30.   go   

1.   --删除测试环境   
2.   drop   table   tb   
3.     
4.     
5.     
6.     
7.   --------------------------------------------   
8.   --     测试2,不使用   updlock     
9.   --------------------------------------------   
10.   --a.创建这样一个测试表   
11.   create   table   tb(a   int)   
12.   insert   tb   select   1   
13.   union   all   select   2   
14.   go   
15.     
16.   --b.查询分析器中新开一个窗口,执行下面的语句   
17.   begin   tran   
18.   declare   @a   int   
19.   select   @a=a   from   tb   
20.   where   a=1   
21.     
22.   waitfor   delay   '00:00:10'   
23.     
24.   select   *   from   tb   
25.   commit   tran   
26.   go   
27.     
28.   --c.再在查询分析器中新开一个窗口,执行下面的语句   
29.   update   tb   set   a=200   
30.     
31.   --结果:   c窗口中的update   立即执行,并没有等待b窗口中的事务提交   
32.   --             可以得到这个结论是因为在b窗口出结果前,c   窗口已经处理完成   
33.   --             而且b窗口得到的结果是a列更新后的值   
34.   go   
35.     
36.   --删除测试环境   
37.   drop   table   tb

updlock
锁定匹配的记录，未匹配到不锁
锁之外的更新，可以更新未匹配到的记录