LCK_M_S Wait Type: Explore Secrets

Performance optimization is crucial in the complex world of SQL servers. LCK_M_S delay types are one of the many difficulties faced by database administrators and developers. In order to clarify this mysterious wait type, we set out to demystify LCK_M_S waits in this article by providing a thorough overview of their relevance, historical background, pros and downsides, causes of occurrence, preventive strategies, useful T-SQL examples, and a list of FAQs.

Introduction (Schema Modification Lock)

The wait type LCK_M_S, which stands for “Lock Manager Shared,” commonly appears in SQL Server setups. These waits represent a process’s request for shared access to a resource that is presently being held hostage by another process, such as a table or a page. It’s essential to comprehend LCK_M_S waits if you want to keep your SQL Server system operating efficiently.

A Glimpse into History

LCK_M_S wait types have existed from the beginning of SQL Server. The requirement for effective resource management and conflict resolution became clear as databases’ complexity and concurrency increased. In order to ensure that many processes may properly share access to resources and avoid data inconsistencies and conflicts, LCK_M_S waits were implemented.

You may also like: Power BI vs SSRS: A Complete Comparison


Control of concurrency

By limiting access to data, the LCK_M_S wait type aids SQL Server in maintaining data integrity. Conflicts are avoided by allowing many transactions to simultaneously read from and hold shared locks on the same resource.

Data Reliability

Shared locks make guarantee that even when other transactions are also gaining access to the same data, the data that one transaction reads is constant during processing. By doing this, read operations are guaranteed to reflect a consistent picture of the data.


LCK_M_S delays are typically small and do not significantly slow down applications. They provide effective concurrent access to data, enhancing the SQL Server’s overall performance.



LCK_M_S wait types can cause blocking, which is their main drawback. Other transactions that require an exclusive lock (LCK_M_X) on the same resource may be delayed until the shared lock is released while one transaction has a shared lock on the resource. Performance constraints and delayed execution may follow from this.


When two or more transactions are waiting for each other to release exclusive locks while holding shared locks, deadlocks can also result from shared locks. Deadlocks can prevent the SQL Server from running normally.

Reduced Concurrency

Although LCK_M_S supports some concurrency, it can nevertheless place restrictions on how much work is done in parallel in situations with lots of transactions. Excessive shared locking might result in resource conflicts and sluggish query processing.

You may also like this article: PAGEIOLATCH_SH: Unveiling the Secrets

Why Do LCK_M_S Wait Types Occur?

SQL Server encounters LCK_M_S (Lock Manager Shared) delay types for the following main causes:

LCK_M_S Wait Type

Shared Lock Request

If no other transactions are currently holding competing locks on the resource (such as a row, page, or table), the shared lock requested by the transaction is given by the SQL Server. Multiple transactions can read the same resource at once because of shared locks.

Resource Contention

When many transactions compete for the same resource’s shared locks, LCK_M_S delays happen. A transaction must wait until the shared lock is relinquished before requesting an exclusive (LCK_M_X) lock on the same resource if one transaction is holding a shared lock. LCK_M_S wait types are a result of this conflict.

Concurrency Control

Data consistency and integrity are maintained via LCK_M_S waits. They make sure that other transactions can read the same resource while one transaction is reading it, but they cannot alter it simultaneously. Data consistency and corruption are avoided via this concurrency control.

Preventing Dirty Reads

Shared locks also stop dirty reads, in which one transaction reads modifications made by another transaction but not yet committed. SQL Server makes sure that a transaction may only read committed data by providing shared locks.

Snapshot Isolation

In some circumstances, SQL Server may employ snapshot isolation, which depends on shared locks to give several transactions a consistent view of the data. This degree of separation guards against reader and writer hostility.

How to Avoid LCK_M_S Wait Type

Consider using the following tactics to prevent LCK_M_S (Lock Manager Shared) wait types in SQL Servers and enhance performance:

Optimize Queries

The chance of LCK_M_S delays can be decreased with properly optimized SQL queries. To reduce shared lock contention, make sure your queries are effective, make use of suitable indexing, and only get what is required.

Use Appropriate Indexing

Implement appropriate indexing techniques to increase the effectiveness of data retrieval. By improving SQL Server’s ability to access data, well-designed indexes can lessen the requirement for shared locks.

Transaction Isolation Levels

For your queries, select the appropriate transaction isolation level. Lower isolation levels, such as READ COMMITTED, might ease shared lock contention but may compromise data consistency.

Avoid Needless Locks

Beware of lock escalation, which can raise the amount of exclusivity on locks. Use row-level or page-level locks where necessary, but unless absolutely essential, avoid locking whole tables or significant amounts of data.

Cut down on transaction time

wherever feasible, shorten transaction times. The possibility that many processes may simultaneously require shared access to the same data decreases as transactions get shorter.

Resource Distribution

Make sure your SQL Server has enough memory and processing power to perform several concurrent read operations without experiencing noticeable delays. Shared lock contention can be better managed by a server with adequate resources.

Examine the Query Execution Plans.

Review and improve query execution plans on a regular basis to spot and fix inefficiencies that might result in long LCK_M_S delays.

Isolation in a Moment

If your application can benefit from snapshot isolation, take it into consideration. By giving each transaction a consistent copy of the data, snapshot isolation enables higher levels of concurrency.

Operations in Bulk

Use batch operations and fewer transactions when conducting bulk inserts or changes to lessen shared lock contention.


To distribute data across several filegroups or discs, use data partitioning techniques. As a result, there will be less competition for shared access to certain data segments and I/O activities will be distributed.

Detection of deadlocks

Utilise systems for deadlock detection and resolution to swiftly end deadlock situations when they arise, reducing the effects of lock contention.


Understanding LCK_M_S delay types is essential for SQL Server optimization. You may improve the performance and stability of your SQL Server system by being aware of its background, benefits, drawbacks, causes, and mitigation techniques. Keep in mind that the best way to reduce LCK_M_S wait times and guarantee lag-free database operations is to combine query optimization, appropriate indexing, and diligent monitoring.


Q: What exactly does LCK_M_S mean?
The acronym LCK_M_S stands for “Lock Manager Shared.”

Q: Do SQL Servers frequently experience LCK_M_S waits?
They do exist in contexts with high concurrency, and they are rather prevalent.

Q: Are LCK_M_S delays limited to SELECT queries only?
They may happen with UPDATE and DELETE queries as well as any activity involving shared resource access, therefore no.

Q: Can data corruption result from LCK_M_S waits?
No, they control resource access to prevent data inconsistency the most.

Q: How can I tell whether my SQL Server has any LCK_M_S waits?
Track delay statistics using SQL Server’s performance monitoring tools.

Q: Can processes be prioritized when experiencing LCK_M_S waits?
Ans: Yes, processes can have priority levels defined by using mechanisms provided by SQL Server.

Q: Can LCK_M_S delays be eliminated via query optimization?
While optimization is helpful, in highly parallel systems total removal might not be practicable.

Q: What distinguishes LCK_M_S and LCK_M_X waits?
Exclusive access requests are indicated by LCK_M_X waits, whereas shared access requests are indicated by LCK_M_S waits.

Q: Can LCK_M_S delays ever be advantageous?
Yes, they guarantee data consistency and avert conflicts in contexts with multiple users.

Q: Should I worry about sporadic LCK_M_S waits?
Although occasional long delays are common, persistently long waits may need to be addressed.


Leave a Comment