LCK_M_IX is a writer that cannot mark its intent on a table, because another session holds a table-wide shared or exclusive lock. Writers do not normally queue here, so when they do, inserts, updates and deletes stall at table level. Run the check to find the table-wide lock.Microsoft’s definition: waiting to acquire an Intent Exclusive (IX) lock. Before a session modifies rows, it places intent exclusive locks on the page and table above them. Intent exclusive is compatible with other intent locks, so this wait means another session holds something table-wide: a shared or exclusive table lock, a shared with intent exclusive lock, or a schema lock.
Is It a Problem?
Yes, if it is sustained, because modifications are held up at table level and users notice. Our SQL Server 2025 lab had 31 waits totalling about 15 seconds in a day. Get Wait Statistics does not filter it out, so if it ranks, you will see it.
Judge it over an interval rather than the cumulative totals. The baseline to monitor is close to zero outside maintenance windows.
Common Causes
- A large read holding a shared table lock, such as a report or export with
TABLOCKorHOLDLOCK, or shared locks escalated to the table. - Another writer’s locks escalated to an exclusive table lock.
- Transactions running under
REPEATABLE READorSERIALIZABLE, which hold shared locks until they commit; .NETTransactionScopedefaults to serializable. - Offline index operations holding the table.
The Check To Run
Rank it against everything else with Get Wait Statistics. While it is happening, find the waiter and its blocker:
SELECT
wt.session_id,
wt.wait_type,
wt.wait_duration_ms,
wt.blocking_session_id,
wt.resource_description,
t.text AS waiting_sql
FROM sys.dm_os_waiting_tasks AS wt
JOIN sys.dm_exec_requests AS r ON r.session_id = wt.session_id
CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) AS t
WHERE wt.wait_type LIKE N'LCK_M_IX%'
ORDER BY wt.wait_duration_ms DESC;
resource_description names the object being fought over. Check the blocker’s isolation level too; level 3 is repeatable read and 4 is serializable:
SELECT
s.session_id,
s.login_name,
s.program_name,
s.transaction_isolation_level
FROM sys.dm_exec_sessions AS s
WHERE s.transaction_isolation_level IN (3, 4);
Both queries need VIEW SERVER STATE.
What To Do
- If a reporting query with table hints is blocking writers, remove the hint, or move the report to a readable secondary or to snapshot isolation.
- Batch large modifications to stay under the escalation threshold, and keep transactions short.
- If an application runs serializable without meaning to, set the isolation level explicitly in its code or connection.
The LCK_M Family
Every lock mode has its own wait type, and the name says which lock the waiting session asked for. The check is the same for all of them: find the waiter, then follow blocking_session_id to the head of the chain.
- LCK_M_X / S / URow and page locks. Exclusive, shared and update, the everyday blocking waits, with the full blocking walkthrough.The main lock waits page
- LCK_M_SCH_SSchema stability. Every query needs it, so a queued SCH-M request stalls them all.Worth investigating
- LCK_M_SCH_MSchema modification. DDL waiting for every user of the table to let go.Worth investigating
- LCK_M_ISIntent shared. A reader cannot mark the table because a writer holds the whole of it.Worth investigating
- LCK_M_IXIntent exclusive. A writer cannot mark the table, so modifications stall at table level.Worth investigating. This page.
- LCK_M_SIXShared with intent exclusive. A transaction that reads the whole table and changes some of it; rare, so any amount stands out.Worth investigating
- LCK_M_RS_SRange shared. Serializable reads locking key ranges; check whether that isolation level was chosen.Worth investigating
- LCK_M_RS_URange update. A serializable search for rows it means to update.Worth investigating
- LCK_M_RX_XRange exclusive. Serializable writes locking the gaps between keys, a common deadlock ingredient.Worth investigating
- LCK_M_RIn_NLInsert range. A serializable insert waiting to lock the gap it lands in.Worth investigating
- _LOW_PRIORITYLow priority variants. Index operations and partition switches waiting under WAIT_AT_LOW_PRIORITY.Usually the feature working
Where To Go Next
If LCK_M_IX is showing up in your wait stats, these are the next places to look.
- LCK_M_X, LCK_M_S, and LCK_M_U, the main lock waits page.
- Troubleshoot SQL Server Blocking, Step by Step, from the first symptom to the head blocker.
- The waits that usually matter, ranked, with what each one is telling you.
- Performance & Troubleshooting, the scripts and guides for this part of the stack.
Leave a Reply