SQL Server

Cómo diagnosticar bloqueos en SQL Server

Encuentra solicitudes bloqueadas, recorre las cadenas hasta el bloqueador principal e inspecciona con seguridad la sesión y la transacción responsables.

Por JaviPublicado Actualizado 15 min de lecturaIntermedio

Tres sesiones de SQL Server conectadas en una cadena de bloqueos, con indicadores de lock en las solicitudes que esperan

Respuesta corta: consulta sys.dm_exec_requests para encontrar las solicitudes con un blocking_session_id distinto de cero, sigue cada bloqueador hasta llegar a una sesión que bloquea a otras sin estar bloqueada (el bloqueador principal) y después revisa la antigüedad de su transacción, su propietario y su último SQL. Reúne esa evidencia antes de que nadie actúe.

¿El bloqueo es el incidente activo? Una vez confirmado el bloqueo y con usuarios afectados, cambia al runbook de bloqueos de SQL Server (en inglés) para seguir el procedimiento operativo paso a paso. Esta página explica cómo encontrar e interpretar la evidencia.

¿No estás seguro de que sea un bloqueo? Para ver primero todo el trabajo activo, usa Ver qué se está ejecutando.

Un bloqueo ocurre cuando una sesión debe esperar a que otra libere un lock incompatible. Esa coordinación es fundamental para la corrección transaccional. El problema en producción son los bloqueos prolongados o inesperados que superan el objetivo de latencia de la carga, crean una cola o impiden reutilizar el log.

Una solicitud bloqueada suele ser víctima de la dependencia, no su causa raíz. Terminar las sesiones bloqueadas reduce la cola visible, pero no explica por qué la transacción bloqueadora sigue abierta.

Problema

Los usuarios informan que las solicitudes de SalesDb terminan por tiempo de espera. Varias sesiones muestran esperas LCK_M_*. Necesitas identificar quién bloquea a quién, encontrar la sesión al comienzo de la cadena e inspeccionar su lote actual o más reciente y la antigüedad de su transacción.

Diagnóstico rápido

Esta consulta lista solicitudes activas bloqueadas. Ejecútala más de una vez: un bloqueo breve que desaparece puede ser normal, mientras que una cadena estable cuyo tiempo de espera aumenta resulta más preocupante.

Consulta SQL: Diagnóstico rápidoT-SQL
SELECT
    SYSDATETIMEOFFSET() AS captured_at,
    r.session_id AS blocked_session_id,
    r.request_id,
    r.blocking_session_id,
    r.status,
    r.wait_type,
    r.wait_time AS wait_time_ms,
    r.wait_resource,
    DB_NAME(r.database_id) AS database_name,
    s.login_name,
    s.host_name,
    s.program_name,
    r.start_time AS request_start_time,
    r.open_transaction_count,
    SUBSTRING(
        sql_text.text,
        (r.statement_start_offset / 2) + 1,
        ((CASE r.statement_end_offset
            WHEN -1 THEN DATALENGTH(sql_text.text)
            ELSE r.statement_end_offset
          END - r.statement_start_offset) / 2) + 1
    ) AS blocked_statement
FROM sys.dm_exec_requests AS r
INNER JOIN sys.dm_exec_sessions AS s
    ON s.session_id = r.session_id
OUTER APPLY sys.dm_exec_sql_text(r.sql_handle) AS sql_text
WHERE r.blocking_session_id > 0
ORDER BY r.wait_time DESC;
T-SQL29 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Bloqueador directo, cadena de bloqueos y bloqueador principal

  1. BloqueadaSesión 92LCK_M_S, blocking_session_id = 81
  2. espera a
    Bloqueada y bloqueanteSesión 81LCK_M_X, blocking_session_id = 65
  3. espera a
    Bloqueador principalSesión 65Inactiva, transacción abierta, sin solicitud activa
Bloqueador directo, cadena y bloqueador principal. La sesión 92 espera a la 81 y la 81 espera a la 65. Solo la 65 no espera a nadie; es el bloqueador principal, a menudo una sesión inactiva que mantiene una transacción abierta.
  • Bloqueador directo: la sesión indicada en el blocking_session_id de una solicitud. Para la sesión 92 es la 81.
  • Cadena de bloqueos: la secuencia de esperas que va de una solicitud bloqueada a la sesión que retiene lo que todos esperan: 92 → 81 → 65. Varias cadenas pueden converger en el mismo bloqueador.
  • Bloqueador principal: una sesión que bloquea a otras sin estar bloqueada. Investigar solo la 81 hace perder el comienzo de la cadena; lo que importa es la transacción de la 65.
  • Bloqueador principal inactivo: una sesión con estado sleeping, sin fila en sys.dm_exec_requests y con open_transaction_count > 0. La aplicación abrió una transacción y dejó de enviar trabajo sin confirmar ni revertir: una ruta de error que se saltó el rollback, una conexión del pool devuelta en mitad de una transacción o una espera del usuario dentro de una transacción. Las consultas sobre solicitudes activas no pueden mostrarla; por eso la consulta del bloqueador principal que sigue parte de sys.dm_exec_sessions.

Consulta: mostrar la cadena de bloqueos

La consulta recursiva parte de las solicitudes bloqueadas y sube por los bloqueadores activos. Evita ciclos y limita la recursión. Describe el grafo de solicitudes actual; más adelante se completa la información del bloqueador principal inactivo, porque no tiene una fila de solicitud activa.

Consulta SQL: Mostrar la cadena de bloqueosT-SQL
;WITH blocking_chain AS
(
    SELECT
        r.session_id,
        r.blocking_session_id,
        r.database_id,
        r.wait_type,
        r.wait_time,
        r.wait_resource,
        0 AS chain_level,
        CAST(CONCAT('/', r.session_id, '/') AS varchar(max)) AS visited
    FROM sys.dm_exec_requests AS r
    WHERE r.blocking_session_id > 0

    UNION ALL

    SELECT
        blocker.session_id,
        blocker.blocking_session_id,
        blocker.database_id,
        blocker.wait_type,
        blocker.wait_time,
        blocker.wait_resource,
        chain.chain_level + 1,
        CAST(CONCAT(chain.visited, blocker.session_id, '/') AS varchar(max))
    FROM blocking_chain AS chain
    INNER JOIN sys.dm_exec_requests AS blocker
        ON blocker.session_id = chain.blocking_session_id
    WHERE chain.visited NOT LIKE CONCAT('%/', blocker.session_id, '/%')
)
SELECT DISTINCT
    chain.chain_level,
    chain.session_id,
    NULLIF(chain.blocking_session_id, 0) AS blocking_session_id,
    DB_NAME(chain.database_id) AS database_name,
    session_info.login_name,
    session_info.host_name,
    session_info.program_name,
    chain.wait_type,
    chain.wait_time AS wait_time_ms,
    chain.wait_resource
FROM blocking_chain AS chain
INNER JOIN sys.dm_exec_sessions AS session_info
    ON session_info.session_id = chain.session_id
ORDER BY chain.chain_level, chain.session_id
OPTION (MAXRECURSION 32);
T-SQL46 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Varias hojas bloqueadas pueden converger en el mismo bloqueador, por eso DISTINCT elimina nodos repetidos. No agrega contadores. El nivel máximo alcanzado desde una hoja no es, por sí solo, una medida de gravedad; céntrate en las sesiones que bloquean a otras y no tienen un bloqueador positivo.

Consulta: inspeccionar el bloqueador principal

Define una sola vez la sesión principal identificada. Esta consulta sirve tanto para una sesión activa como para una inactiva y muestra la antigüedad de la transacción y su texto actual o más reciente.

Consulta SQL: Inspeccionar el bloqueador principalT-SQL
DECLARE @HeadBlockerSessionId int = 65;

SELECT
    SYSDATETIMEOFFSET() AS captured_at,
    s.session_id,
    s.login_time,
    s.status AS session_status,
    s.login_name,
    s.host_name,
    s.program_name,
    DB_NAME(COALESCE(r.database_id, s.database_id)) AS database_name,
    r.status AS request_status,
    r.command,
    r.start_time AS request_start_time,
    r.wait_type,
    r.cpu_time AS cpu_time_ms,
    r.logical_reads,
    r.writes,
    s.open_transaction_count,
    at.transaction_begin_time,
    DATEDIFF(second, at.transaction_begin_time, SYSDATETIME()) AS transaction_age_seconds,
    log_use.log_bytes_used,
    sql_text.text AS current_or_most_recent_batch
FROM sys.dm_exec_sessions AS s
LEFT JOIN sys.dm_exec_requests AS r
    ON r.session_id = s.session_id
LEFT JOIN sys.dm_exec_connections AS c
    ON c.session_id = s.session_id
LEFT JOIN sys.dm_tran_session_transactions AS st
    ON st.session_id = s.session_id
LEFT JOIN sys.dm_tran_active_transactions AS at
    ON at.transaction_id = st.transaction_id
OUTER APPLY (
    SELECT SUM(dt.database_transaction_log_bytes_used) AS log_bytes_used
    FROM sys.dm_tran_database_transactions AS dt
    WHERE dt.transaction_id = st.transaction_id
) AS log_use
OUTER APPLY sys.dm_exec_sql_text(COALESCE(r.sql_handle, c.most_recent_sql_handle)) AS sql_text
WHERE s.session_id = @HeadBlockerSessionId;
T-SQL39 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Cómo interpretar el resultado

Las esperas de lock empiezan por LCK_M_; el sufijo describe el modo de lock solicitado. El recurso de espera puede identificar una base de datos, objeto, página, clave o recurso de metadatos, pero descifrarlo es un paso para llegar a la operación bloqueada, no una solución automática. Determina las instrucciones, los límites de transacción, el nivel de aislamiento, las filas afectadas y las rutas de acceso de los índices.

Un bloqueador principal activo puede estar realizando trabajo legítimo. Un bloqueador principal inactivo con una transacción abierta desde hace tiempo merece especial atención: el cliente quizá dejó de enviar trabajo sin confirmar ni revertir la transacción. El lote más reciente da una pista, pero puede no ser la instrucción que adquirió todos los locks que siguen retenidos.

Qué puede significar el resultado

Las transacciones largas, las actualizaciones grandes, los predicados poco selectivos, los scans que tocan más claves, la interacción del usuario dentro de una transacción y la falta de rutas de commit/rollback pueden prolongar los bloqueos. Un índice deficiente puede aumentar la cantidad y duración de los recursos bloqueados, pero añadir un índice no es automáticamente la respuesta correcta. Cambiar el nivel de aislamiento altera la semántica de consistencia y debe ser una decisión arquitectónica, no un atajo durante un incidente.

Los deadlocks son distintos. En un deadlock, las sesiones forman un ciclo y SQL Server elige una víctima para que otra transacción pueda continuar. Un bloqueo normal es una línea o árbol de esperas que puede persistir. Investiga los deadlocks con sus grafos; no esperes que esta instantánea reconstruya uno que ya terminó.

Qué revisar después

Inspecciona el plan del bloqueador principal, el código transaccional y quién es responsable de la aplicación. Comprueba cuántas filas modifica, si los predicados son selectivos y si algún error puede omitir el rollback. Para incidentes recurrentes, captura informes de procesos bloqueados o una sesión adecuada de Extended Events para conservar las evidencias después de que terminen.

Evidencia que reunir antes de actuar

Evidencia De dónde sale Por qué importa
session_id y login_time del bloqueador principal sys.dm_exec_sessions Los ID de sesión se reutilizan; login_time confirma que sigues viendo la misma conexión
Número de solicitudes bloqueadas y la espera más larga La primera consulta, ejecutada varias veces Muestra si la cadena crece, se mantiene o se resuelve
Hora de inicio y antigüedad de la transacción sys.dm_tran_active_transactions Una transacción antigua retiene bloqueos más tiempo y puede impedir la reutilización del log
Bytes de log usados por la transacción sys.dm_tran_database_transactions Una indicación aproximada de cuánto trabajo tendría que deshacer un rollback
Login, host y aplicación sys.dm_exec_sessions De quién es la sesión y a quién contactar
SQL actual o más reciente sys.dm_exec_sql_text o sys.dm_exec_input_buffer Qué hacía la transacción; no prueba qué instrucción tomó cada bloqueo
Tipo y recurso de espera de las solicitudes bloqueadas sys.dm_exec_requests El modo de bloqueo solicitado y el objeto, página o clave implicados
Base de datos y hora de inicio de la solicitud sys.dm_exec_requests El alcance del impacto y cuánto dura

Pon marca de tiempo a cada captura y guárdala fuera de la base afectada. Durante un incidente, el runbook incluye una plantilla de evidencias (en inglés) para completar antes de cualquier mitigación.

Errores frecuentes

  • Terminar la sesión bloqueada y dejar abierta la transacción principal.
  • Suponer que cualquier bloqueo es anormal y debilitar el aislamiento sin analizar los requisitos.
  • Leer una sola instantánea sin medir cuánto persiste la condición.
  • Tratar most_recent_sql_handle como prueba definitiva de la instrucción que mantiene cada lock.
  • Usar NOLOCK como solución universal pese a los resultados incoherentes o incompletos.
  • Confundir una cadena de bloqueos con un ciclo de deadlock.

Notas de producción y riesgo de KILL

Si estás gestionando un incidente de producción activo, usa el runbook de bloqueos de SQL Server (en inglés).

KILL no es una consulta de diagnóstico. Terminar el bloqueador principal revierte su transacción abierta; el rollback puede durar tanto como el trabajo original o más y seguir reteniendo locks. También puede interrumpir una operación de negocio crítica. Si es necesario terminarla para proteger la disponibilidad, vuelve a verificar la identidad de la sesión, coordínate con el responsable, captura evidencias y planifica el monitoreo del rollback.

La salida de las DMV es temporal y los permisos varían según la versión de SQL Server. Conserva muestras con marca de tiempo de forma segura. Una solución duradera normalmente reduce el alcance o la duración de la transacción, corrige la gestión transaccional de la aplicación, mejora el plan de acceso o cambia el diseño de concurrencia sin perder la consistencia requerida.

Continuar el recorrido de rendimiento

Usa la evidencia de bloqueos dentro del flujo de optimización. Si el aviso es una lentitud general y no un bloqueo conocido, empieza por SQL Server va lento: los primeros 15 minutos. Vuelve a las consultas en ejecución, inspecciona el bloqueador con la guía del ID de sesión y usa las regresiones de Query Store cuando la lentitud ya haya pasado. Referencias rápidas: Encontrar bloqueos y Encontrar transacciones abiertas.

Fuentes

Revisado en noviembre de 2026. Para ver otras sesiones, SQL Server 2019 y versiones anteriores requieren VIEW SERVER STATE; a partir de SQL Server 2022, Microsoft documenta VIEW SERVER PERFORMANCE STATE para las DMV de sesión y de transacción.

Etiquetas

  • SQL Server
  • Rendimiento
  • Solución de problemas
  • DMV
  • Bloqueos
  • Concurrencia