Lock types (shared, exclusive) in MySQL - Time & Space Complexity
When databases use locks, they control how many users can access data at the same time.
We want to understand how the time to get and release locks changes as more users try to access the data.
Analyze the time complexity of acquiring shared and exclusive locks in MySQL.
-- Transaction 1 requests a shared lock
LOCK TABLES orders READ;
-- Transaction 2 requests an exclusive lock
LOCK TABLES orders WRITE;
-- Transaction 1 releases lock
UNLOCK TABLES;
-- Transaction 2 acquires exclusive lock after Transaction 1
LOCK TABLES orders WRITE;
This code shows two transactions trying to lock the same table with different lock types.
Locks are requested and released repeatedly as transactions run.
- Primary operation: Checking and waiting for lock availability.
- How many times: Once per lock request, but can repeat if waiting.
As more transactions request locks, waiting time can increase.
| Number of Transactions (n) | Approx. Lock Wait Checks |
|---|---|
| 10 | Up to 10 checks |
| 100 | Up to 100 checks |
| 1000 | Up to 1000 checks |
Pattern observation: The time to get a lock grows roughly in direct proportion to the number of transactions waiting.
Time Complexity: O(n)
This means the time to acquire a lock grows linearly as more transactions try to lock the same resource.
[X] Wrong: "Locks always happen instantly, no matter how many users wait."
[OK] Correct: When many transactions wait, each must check and wait their turn, so time grows with the number of waiters.
Understanding how locks affect performance helps you explain database behavior clearly and shows you know how systems handle multiple users safely.
"What if we changed from table-level locks to row-level locks? How would the time complexity change?"
Practice
Solution
Step 1: Understand shared lock behavior
A shared lock allows many users to read the same data at the same time safely.Step 2: Compare with other lock types
Exclusive locks prevent others from reading or writing, but shared locks only prevent writing.Final Answer:
Allow multiple users to read data simultaneously without conflicts -> Option AQuick Check:
Shared lock = multiple readers allowed [OK]
- Confusing shared lock with exclusive lock
- Thinking shared locks block reading
- Assuming shared locks allow writing
Solution
Step 1: Recall MySQL lock syntax
In MySQL, to acquire a shared lock, you useLOCK TABLES table_name READ;.Step 2: Eliminate incorrect options
WRITEis for exclusive locks,EXCLUSIVEandSHAREare not valid MySQL lock keywords.Final Answer:
LOCK TABLES table_name READ; -> Option DQuick Check:
Shared lock syntax uses READ keyword [OK]
- Using WRITE instead of READ for shared lock
- Using unsupported keywords like EXCLUSIVE or SHARE
- Confusing lock syntax with SQL SELECT statements
Solution
Step 1: Understand lock compatibility
Shared locks allow multiple readers but block exclusive locks until released.Step 2: Analyze the scenario
Transaction B must wait for Transaction A to release the shared lock before getting exclusive lock.Final Answer:
Transaction B waits until Transaction A releases the shared lock -> Option BQuick Check:
Exclusive lock waits for shared locks to release [OK]
- Assuming exclusive lock can override shared lock immediately
- Thinking shared lock releases automatically
- Believing both locks can coexist on same data
LOCK TABLES my_table SHARE;
What is the error and how to fix it?
Solution
Step 1: Identify invalid lock keyword
MySQL does not support 'SHARE' as a lock type; it uses 'READ' or 'WRITE'.Step 2: Correct the lock type
To lock for writing, useLOCK TABLES my_table WRITE;instead.Final Answer:
Error: Invalid lock type 'SHARE'. Fix: Use 'WRITE' instead of 'SHARE'. -> Option CQuick Check:
Use WRITE for exclusive lock, SHARE is invalid [OK]
- Using unsupported lock keywords
- Ignoring error messages about syntax
- Assuming SHARE is synonym for READ
Solution
Step 1: Understand shared and exclusive lock roles
Shared locks allow multiple readers; exclusive locks allow one writer.Step 2: Apply correct locks for reading and writing
Use shared locks for reading so many users can read safely, and exclusive locks for updating to prevent conflicts.Final Answer:
Use shared locks (READ) for reading and exclusive locks (WRITE) for updating -> Option AQuick Check:
Shared for read, exclusive for write ensures safe concurrency [OK]
- Using exclusive locks for reading blocks all users
- Using shared locks for writing causes conflicts
- Ignoring locks and risking data corruption
Ready to prove it?
Pass the test and this pattern moves unknown
