Wait Type LCK_M_SIX

Wait statistics, in the context of SQL Server, refer to the amount of time that a query spends waiting to access data in the database. When a client application requests data from the database, the request is placed in a queue and the client application must wait for its turn to access the data. The time that the query spends waiting is called a "wait" and is tracked by SQL Server. This information can be used to identify potential performance bottlenecks and optimize the performance of the database. Wait statistics are commonly used by database administrators to diagnose and troubleshoot performance issues in SQL Server.

SQL Server uses a variety of locks to manage data access and ensure consistency. One specific type of lock-related wait is LCK_M_SIX, which stands for “Shared with Intent Exclusive” lock. This wait type can appear when SQL Server is trying to read data while reserving the option to modify it, a mechanism that can prevent data conflicts and ensure smooth transaction processing. In this post, we’ll explain what LCK_M_SIX means, when it shows up, and what it could imply for your SQL Server environment.

What Is the LCK_M_SIX Wait Type?

The LCK_M_SIX wait type occurs when SQL Server is waiting to acquire a “Shared with Intent Exclusive” (SIX) lock on a resource, usually a table or a row. An SIX lock is a combination of two types of locks:

• Shared Lock (S) – Allows a transaction to read data while preventing other transactions from modifying it at the same time.
• Intent Exclusive Lock (IX) – Indicates that the transaction may want to update or modify the data it’s reading.

The SIX lock effectively allows SQL Server to read data with the intent to update it if necessary, ensuring that other processes cannot modify the data until the operation is complete. If SQL Server cannot acquire this lock right away, it will experience an LCK_M_SIX wait as it waits for other transactions to release the required resources.

When Does LCK_M_SIX Appear?

You might encounter LCK_M_SIX waits in SQL Server in the following scenarios:

• Complex Transactions – In transactions where SQL Server needs to both read and possibly update data, it may request an SIX lock, resulting in LCK_M_SIX waits if other processes hold incompatible locks.
• Bulk Update Operations – During bulk updates that need to read large portions of data and then modify it, SQL Server may use SIX locks, causing LCK_M_SIX waits if other transactions are accessing the same data.
• High-Concurrency Environments – In systems with many simultaneous transactions, SIX lock waits may increase as SQL Server manages access to commonly used tables or rows.

Some LCK_M_SIX waits are expected in a high-concurrency environment. However, prolonged waits might indicate contention issues, particularly if multiple transactions are waiting for access to the same resources.

Why LCK_M_SIX Waits Matter

While LCK_M_SIX waits are a normal part of SQL Server’s locking system to manage complex transactions, high or frequent waits can cause slowdowns, especially if multiple processes are waiting on an SIX lock. If transactions are frequently delayed due to SIX locks, it can impact the overall performance and responsiveness of your SQL Server environment.

Common causes of high LCK_M_SIX waits include:

• Contention on Shared Resources – High demand on specific tables or rows by multiple processes can increase lock contention and lead to SIX waits.
• Long-Running Transactions – Transactions that hold locks for extended periods prevent other transactions from acquiring necessary locks, leading to more LCK_M_SIX waits.
• High Volume of Read-and-Write Operations – Heavy workloads that involve reading data with the intent to modify it can increase SIX lock requests and wait times.

How to Address LCK_M_SIX Waits

If you are seeing frequent or prolonged LCK_M_SIX waits, consider the following actions to minimize their impact:

• Optimize Transaction Length – Shortening the duration of transactions can help reduce lock wait times by allowing other transactions to access resources more quickly.
• Implement Indexing Strategies – Effective indexing can help SQL Server retrieve data more efficiently, reducing the need for complex lock types like SIX.
• Stagger or Batch Updates – If possible, schedule or batch updates during off-peak hours or spread them out to minimize lock contention.
• Analyze Locking Patterns – Use SQL Server’s monitoring tools to identify where SIX locks are most frequently requested and determine if there are ways to optimize these queries or workloads.

Conclusion

The LCK_M_SIX wait type in SQL Server is an indication that the system is waiting on a “Shared with Intent Exclusive” lock. This lock is a necessary mechanism for managing complex transactions that involve both reading and possibly updating data. While some SIX waits are normal, frequent or prolonged LCK_M_SIX waits could suggest contention issues in your database. By optimizing transactions, improving indexing, and managing high-demand updates, you can help reduce LCK_M_SIX waits and improve SQL Server performance.

For expert assistance with SQL Server performance tuning and lock management, Stedman Solutions offers managed services to help keep your SQL Server environment running smoothly and efficiently.

Find out more about our SQL Server Managed Services

Applies to

Related Waits

See Also

• More About LCK_M_SIX