LCK_M_RS_U_ABORT_BLOCKERS Wait Type Explained

This wait type manifests when the lock manager processes ALTER TABLE or ALTER INDEX statements configured with WAIT_AT_LOW_PRIORITY and ABORT_AFTER_WAIT options. The RS_U component indicates a Range Scan Update lock, which protects both the current key and the range between keys during index operations.

The ABORT_BLOCKERS suffix directly corresponds to the ABORT_AFTER_WAIT = BLOCKERS option, which instructs SQL Server to terminate blocking transactions rather than waiting indefinitely. When the lock manager encounters existing shared or exclusive locks on the target range, it queues this specific wait type until the abort timeout expires.

SQL Server's lock compatibility matrix treats RS_U locks as incompatible with most other lock types. The lock manager must acquire both the key-level update lock and the range lock atomically, creating a coordination point where multiple operations can conflict. This differs from standard update locks because range locks prevent phantom reads during the schema modification.

The wait occurs in the lock manager's grant queue when conflicting locks exist. SQL Server 2014 introduced this mechanism to provide more granular control over DDL blocking behavior. Prior versions would either wait indefinitely or fail immediately without the ABORT_BLOCKERS option.

Version-specific behavior remains consistent from SQL Server 2014 through 2022, with the primary difference being improved lock escalation algorithms in newer versions that may reduce the frequency of these waits.

-- Identify current LCK_M_RS_U_ABORT_BLOCKERS waits and blocking chains
SELECT 
    r.session_id,
    r.wait_type,
    r.wait_time_ms,
    r.wait_resource,
    r.blocking_session_id,
    s.program_name,
    t.text AS current_sql
FROM sys.dm_exec_requests r
INNER JOIN sys.dm_exec_sessions s ON r.session_id = s.session_id
CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) t
WHERE r.wait_type = 'LCK_M_RS_U_ABORT_BLOCKERS';

-- Check for active ALTER operations with ABORT_AFTER_WAIT configured
SELECT 
    r.session_id,
    r.percent_complete,
    r.estimated_completion_time,
    r.command,
    t.text AS full_command
FROM sys.dm_exec_requests r
CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) t
WHERE t.text LIKE '%ABORT_AFTER_WAIT%'
AND r.command IN ('ALTER TABLE', 'ALTER INDEX');

-- Analyze historical wait statistics for this wait type
SELECT 
    wait_type,
    waiting_tasks_count,
    wait_time_ms,
    max_wait_time_ms,
    signal_wait_time_ms,
    wait_time_ms / waiting_tasks_count AS avg_wait_time_ms
FROM sys.dm_os_wait_stats 
WHERE wait_type = 'LCK_M_RS_U_ABORT_BLOCKERS';

-- Examine lock resources and compatibility conflicts
SELECT 
    tl.resource_type,
    tl.resource_database_id,
    tl.resource_associated_entity_id,
    tl.request_mode,
    tl.request_type,
    tl.request_status,
    tl.request_session_id,
    OBJECT_NAME(p.object_id, tl.resource_database_id) AS object_name
FROM sys.dm_tran_locks tl
LEFT JOIN sys.partitions p ON tl.resource_associated_entity_id = p.hobt_id
WHERE tl.request_session_id IN (
    SELECT session_id FROM sys.dm_exec_requests 
    WHERE wait_type = 'LCK_M_RS_U_ABORT_BLOCKERS'
);

Terminate blocking sessions manually This script identifies and kills sessions blocking the ALTER operation when ABORT_AFTER_WAIT timeout is insufficient.

-- Find and terminate blocking sessions for RS_U_ABORT_BLOCKERS waits
DECLARE @BlockingSessionId INT;
SELECT @BlockingSessionId = blocking_session_id
FROM sys.dm_exec_requests 
WHERE wait_type = 'LCK_M_RS_U_ABORT_BLOCKERS';

IF @BlockingSessionId > 0
BEGIN
    DECLARE @KillCommand NVARCHAR(20) = 'KILL ' + CAST(@BlockingSessionId AS NVARCHAR(10));
    PRINT 'Executing: ' + @KillCommand;
    -- EXEC(@KillCommand); -- Uncomment after verification
END;

Test in development first. Killing sessions may cause transaction rollbacks and application errors.

Modify timeout duration for ALTER operations Increases the ABORT_AFTER_WAIT timeout to allow more time for blocking transactions to complete naturally.

-- Template for adjusting ABORT_AFTER_WAIT timeout
-- Replace [TableName] and [IndexName] with actual values
ALTER INDEX [IndexName] ON [TableName]
REBUILD 
WITH (ONLINE = ON (WAIT_AT_LOW_PRIORITY (MAX_DURATION = 5 MINUTES, 
                                         ABORT_AFTER_WAIT = BLOCKERS)));

Longer timeouts reduce the need for forced termination but may extend maintenance windows.

Switch to SELF abort option Changes the abort behavior to terminate the ALTER operation instead of blocking sessions.

-- Modified ALTER statement using ABORT_AFTER_WAIT = SELF
-- This terminates the ALTER operation instead of blocking transactions
ALTER TABLE [YourTable] 
ALTER COLUMN [YourColumn] VARCHAR(100)
WITH (ONLINE = ON (WAIT_AT_LOW_PRIORITY (MAX_DURATION = 2 MINUTES, 
                                         ABORT_AFTER_WAIT = SELF)));

SELF option protects existing workloads but may require rescheduling the DDL operation.

Configure maintenance windows during periods of minimal transactional activity to reduce lock conflicts. Monitor sys.dm_tran_locks before executing ALTER operations to identify potential blocking scenarios.

Use the WAIT_AT_LOW_PRIORITY option strategically based on business requirements. ABORT_AFTER_WAIT = SELF prevents disruption to existing workloads when schema changes can be rescheduled. ABORT_AFTER_WAIT = BLOCKERS should only be used when schema modifications are critical and blocking sessions can be safely terminated.

Implement pre-flight checks that query sys.dm_exec_requests and sys.dm_tran_locks to verify minimal blocking before executing ALTER statements. Consider breaking large index operations into smaller batches using partial rebuilds when supported by the SQL Server edition.

Set appropriate MAX_DURATION values based on historical transaction durations. Monitor wait statistics regularly to identify patterns that indicate suboptimal timeout configurations. Configure alerts on LCK_M_RS_U_ABORT_BLOCKERS waits exceeding baseline thresholds.

Design application transaction patterns to minimize long-running queries during scheduled maintenance periods. Implement retry logic in applications to handle potential session terminations from ABORT_AFTER_WAIT operations.