如何找到锁定我的表的内容

Question

我有一个SQL表突然无法返回数据,除非我在末尾包含"with(nolock)",这表示我的表上有某种锁.我已经用dm_tran_locks进行了一些实验,以确定表中实际上存在多个锁,但是如何识别锁定它们的是什么(即dm_tran_locks的请求元素)？

编辑:我知道SQL 2005之前的sp_lock,但现在不推荐使用sp,AFAIK正确的做法是使用dm_tran_locks.我正在使用SQL Server 2008 R2.

Answer 1

查看以下系统存储过程,您可以在SQLServer Management Studio(SSMS)中运行它们:

• sp_who的
• sp_lock的

此外,在SSMS中,您可以以不同方式查看锁和进程:

不同版本的SSMS将活动监视器放在不同的位置.例如,当您右键单击服务器节点时,SSMS 2008和2012会在上下文菜单中将其包含在内.

Answer 2

为了直接"阻止/阻塞谁",我将sp_who和sp_lock组合/缩写为单个查询,这可以很好地概述谁将哪个对象锁定到什么级别.

--Create Procedure WhoLock
--AS
set nocount on
if object_id('tempdb..#locksummary') is not null Drop table #locksummary
if object_id('tempdb..#lock') is not null Drop table #lock
create table #lock (    spid int,    dbid int,    objId int,    indId int,    Type char(4),    resource nchar(32),    Mode char(8),    status char(6))
Insert into #lock exec sp_lock
if object_id('tempdb..#who') is not null Drop table #who
create table #who (     spid int, ecid int, status char(30),
            loginame char(128), hostname char(128),
            blk char(5), dbname char(128), cmd char(16)
            --
            , request_id INT --Needed for SQL 2008 onwards
            --
         )
Insert into #who exec sp_who
Print '-----------------------------------------'
Print 'Lock Summary for ' + @@servername  + ' (excluding tempdb):'
Print '-----------------------------------------' + Char(10)
Select     left(loginame, 28) as loginame, 
    left(db_name(dbid),128) as DB,
    left(object_name(objID),30) as object,
    max(mode) as [ToLevel],
    Count(*) as [How Many],
    Max(Case When mode= 'X' Then cmd Else null End) as [Xclusive lock for command],
    l.spid, hostname
into #LockSummary
from #lock l join #who w on l.spid= w.spid
where dbID != db_id('tempdb') and l.status='GRANT'
group by dbID, objID, l.spid, hostname, loginame

Select * from #LockSummary order by [ToLevel] Desc, [How Many] Desc, loginame, DB, object

Print '--------'
Print 'Who is blocking:'
Print '--------' + char(10)
SELECT p.spid
,convert(char(12), d.name) db_name
, program_name
, p.loginame
, convert(char(12), hostname) hostname
, cmd
, p.status
, p.blocked
, login_time
, last_batch
, p.spid
FROM      master..sysprocesses p
JOIN      master..sysdatabases d ON p.dbid =  d.dbid
WHERE     EXISTS (  SELECT 1
          FROM      master..sysprocesses p2
          WHERE     p2.blocked = p.spid )

Print '--------'
Print 'Details:'
Print '--------' + char(10)
Select     left(loginame, 30) as loginame,  l.spid,
    left(db_name(dbid),15) as DB,
    left(object_name(objID),40) as object,
    mode ,
    blk,
    l.status
from #lock l join #who w on l.spid= w.spid
where dbID != db_id('tempdb') and blk <>0
Order by mode desc, blk, loginame, dbID, objID, l.status

(有关锁定级别缩写的含义,请参阅https://technet.microsoft.com/en-us/library/ms175519%28v=sql.105%29.aspx)

复制自:sp_WhoLock - 一个结合了sp_who和sp_lock的T-SQL存储过程...

注意[命令的Xclusive lock]列可能会产生误导 - 它显示该spid的当前命令; 但是X锁可能是由事务中的早期命令触发的.

Answer 3

我有一个存储过程,我已经放在一起,不仅处理锁和阻塞,而且还查看服务器中正在运行的内容.我已把它放在主人.我将与您分享,代码如下:

USE [master]
go


CREATE PROCEDURE [dbo].[sp_radhe] 

AS
BEGIN

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED


-- the current_processes
-- marcelo miorelli 
-- CCHQ 
-- 04 MAR 2013 Wednesday

SELECT es.session_id AS session_id
,COALESCE(es.original_login_name, '') AS login_name
,COALESCE(es.host_name,'') AS hostname
,COALESCE(es.last_request_end_time,es.last_request_start_time) AS last_batch
,es.status
,COALESCE(er.blocking_session_id,0) AS blocked_by
,COALESCE(er.wait_type,'MISCELLANEOUS') AS waittype
,COALESCE(er.wait_time,0) AS waittime
,COALESCE(er.last_wait_type,'MISCELLANEOUS') AS lastwaittype
,COALESCE(er.wait_resource,'') AS waitresource
,coalesce(db_name(er.database_id),'No Info') as dbid
,COALESCE(er.command,'AWAITING COMMAND') AS cmd
,sql_text=st.text
,transaction_isolation =
CASE es.transaction_isolation_level
    WHEN 0 THEN 'Unspecified'
    WHEN 1 THEN 'Read Uncommitted'
    WHEN 2 THEN 'Read Committed'
    WHEN 3 THEN 'Repeatable'
    WHEN 4 THEN 'Serializable'
    WHEN 5 THEN 'Snapshot'
END
,COALESCE(es.cpu_time,0) 
    + COALESCE(er.cpu_time,0) AS cpu
,COALESCE(es.reads,0) 
    + COALESCE(es.writes,0) 
    + COALESCE(er.reads,0) 
+ COALESCE(er.writes,0) AS physical_io
,COALESCE(er.open_transaction_count,-1) AS open_tran
,COALESCE(es.program_name,'') AS program_name
,es.login_time
FROM sys.dm_exec_sessions es
LEFT OUTER JOIN sys.dm_exec_connections ec ON es.session_id = ec.session_id
LEFT OUTER JOIN sys.dm_exec_requests er ON es.session_id = er.session_id
LEFT OUTER JOIN sys.server_principals sp ON es.security_id = sp.sid
LEFT OUTER JOIN sys.dm_os_tasks ota ON es.session_id = ota.session_id
LEFT OUTER JOIN sys.dm_os_threads oth ON ota.worker_address = oth.worker_address
CROSS APPLY sys.dm_exec_sql_text(er.sql_handle) AS st
where es.is_user_process = 1 
  and es.session_id <> @@spid
  and es.status = 'running'
ORDER BY es.session_id

end 

GO

在过去的几年里,这个程序对我来说非常好.运行它只需键入sp_radhe

关于将sp_radhe放在master数据库中

我使用以下代码并使其成为系统存储过程

exec sys.sp_MS_marksystemobject 'sp_radhe'

正如您在下面的链接中看到的那样

创建自己的SQL Server系统存储过程

关于事务隔离级别

关于T-SQL事务隔离级别的问题,你太害羞了

Jonathan Kehayias

一旦更改了事务隔离级别,它只会在过程结束时返回作用域或返回调用时更改,或者如果使用SET TRANSACTION ISOLATION LEVEL再次显式更改它.

此外,TRANSACTION ISOLATION LEVEL仅限于存储过程,因此您可以拥有多个嵌套存储过程,这些过程以其自己的特定隔离级别执行.

Answer 4

exec sp_lock

此查询应该为您提供现有锁.

exec sp_who SPID -- will give you some info

有spid,你可以检查活动监视器(进程选项卡),找出锁定表的进程("详细信息"获取更多信息,"杀死进程"杀死它).

Answer 5

这应该为您提供现有锁的所有详细信息。

DECLARE @tblVariable TABLE(SPID INT, Status VARCHAR(200), [Login] VARCHAR(200), HostName VARCHAR(200), 
    BlkBy VARCHAR(200), DBName VARCHAR(200), Command VARCHAR(200), CPUTime INT, 
    DiskIO INT, LastBatch VARCHAR(200), ProgramName VARCHAR(200), _SPID INT, 
    RequestID INT)

INSERT INTO @tblVariable
EXEC Master.dbo.sp_who2

SELECT v.*, t.TEXT 
FROM @tblVariable v
INNER JOIN sys.sysprocesses sp ON sp.spid = v.SPID
CROSS APPLY sys.dm_exec_sql_text(sp.sql_handle) AS t
ORDER BY BlkBy DESC, CPUTime DESC

然后，您可以谨慎地终止阻止您的表的 SPID。

kill 104 -- Your SPID

Answer 6

您还可以使用sp_who2which 提供更多信息

这是一些信息http://dbadiaries.com/using-sp_who2-to-help-with-sql-server-troubleshooting