Thread safety in design in LLD - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does thread safety mean in system design?

Thread safety means that a piece of code or design works correctly when multiple threads access it at the same time without causing errors or unexpected behavior.

beginner

Name one common problem caused by lack of thread safety.

Race conditions, where two or more threads try to change shared data at the same time, causing wrong or unpredictable results.

intermediate

What is a mutex and how does it help with thread safety?

A mutex is a lock that allows only one thread to access a resource at a time, preventing conflicts and ensuring thread safety.

intermediate

Explain immutable objects and their role in thread safety.

Immutable objects cannot be changed after creation, so multiple threads can read them safely without locks, making design simpler and safer.

advanced

What is the difference between concurrent and parallel execution in thread safety context?

Concurrent means multiple threads make progress by switching time slices, while parallel means threads run at the same time on different processors. Both need thread safety to avoid conflicts.

Which of the following best describes a race condition?

A A thread running alone without interruption

B Multiple threads accessing shared data without proper synchronization

C A thread waiting for a lock to be released

D Using immutable objects in design

Race condition happens when multiple threads access shared data simultaneously without synchronization, causing errors.

What does a mutex do in thread-safe design?

A Allows multiple threads to write data simultaneously

B Schedules threads to run in parallel

C Makes objects immutable

D Prevents multiple threads from accessing a resource at the same time

A mutex locks a resource so only one thread can access it at a time, ensuring thread safety.

Why are immutable objects considered thread-safe?

A Because they can be changed by any thread anytime

B Because they use locks internally

C Because they never change after creation, so no conflicts occur

D Because they run on a single thread

Immutable objects do not change, so multiple threads can read them safely without synchronization.

Which technique is NOT typically used to achieve thread safety?

A Ignoring shared data access

B Making objects immutable

C Using locks or mutexes

D Using atomic operations

Ignoring shared data access can cause race conditions and is not a thread safety technique.

What is the main goal of thread-safe design?

A To prevent errors when multiple threads access shared resources

B To make code run faster by using more threads

C To avoid using threads altogether

D To allow threads to share memory without restrictions

Thread-safe design ensures correct behavior when multiple threads access shared resources.

Describe what thread safety means and why it is important in system design.

Think about what happens when many people try to use the same tool at once.

List and explain at least three techniques to achieve thread safety in a design.

Consider how to control access or avoid conflicts.

Practice

1. What does thread safety in system design primarily ensure?

easy

A. Multiple threads can access shared data without causing errors

B. The system runs faster by using more threads

C. Only one thread runs at a time in the entire system

D. Threads do not use any shared resources

Solution

1. Step 1: Understand thread safety concept

   Thread safety means multiple threads can work with shared data without causing conflicts or errors.

2. Step 2: Analyze options

   Multiple threads can access shared data without causing errors correctly states this. Options B, C, and D misunderstand thread safety or describe unrelated concepts.

3. Final Answer:

   Multiple threads can access shared data without causing errors -> Option A

4. Quick Check:

   Thread safety = safe shared data access [OK]

Hint: Thread safety means safe shared data access [OK]

Common Mistakes:

• Confusing thread safety with performance
• Thinking only one thread runs at a time
• Assuming no shared data is used

2. Which of the following is the correct way to declare a lock object in a typical low-level design for thread safety?

easy

A. lock = synchronized()

B. lock = new Lock()

C. lock = create_lock()

D. lock = Lock()

Solution

1. Step 1: Identify common lock declaration syntax

   In many low-level designs, a lock is created by calling a constructor like Lock().

2. Step 2: Compare options

   lock = Lock() uses lock = Lock(), which is typical. lock = new Lock() uses 'new' which is not common in low-level design languages. lock = create_lock() and D use incorrect or non-standard functions.

3. Final Answer:

   lock = Lock() -> Option D

4. Quick Check:

   Lock creation = Lock() [OK]

Hint: Lock objects are usually created by calling Lock() [OK]

Common Mistakes:

• Using 'new' keyword incorrectly
• Assuming lock creation uses special functions
• Confusing lock with synchronization keyword

3. Consider this pseudocode for a shared counter increment:

lock.acquire()
counter = counter + 1
lock.release()
print(counter)

If two threads run this code simultaneously starting with counter = 0, what is the possible output?

medium

A. 0

B. 3

C. 2

D. Any number greater than 2

Solution

1. Step 1: Understand lock usage in code

   The lock ensures only one thread increments the counter at a time, preventing race conditions.

2. Step 2: Calculate final counter value

   Two threads each increment once, so counter goes from 0 to 2 safely.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Lock ensures increments are safe, so counter = 2 [OK]

Hint: Locks prevent lost updates, so increments add up [OK]

Common Mistakes:

• Ignoring lock and assuming race condition
• Thinking output can be 0 or 1 due to concurrency
• Assuming counter can exceed 2 without loops

4. In this code snippet, what is the main thread safety issue?

lock.acquire()
shared_list.append(1)
# Missing lock.release()

medium

A. No issue, code is safe

B. Deadlock due to missing lock release

C. Syntax error in lock usage

D. Race condition on shared_list

Solution

1. Step 1: Analyze lock usage

   The code acquires a lock but never releases it, causing other threads to wait forever.

2. Step 2: Identify consequence

   This causes a deadlock, where threads block indefinitely waiting for the lock.

3. Final Answer:

   Deadlock due to missing lock release -> Option B

4. Quick Check:

   Missing release = deadlock [OK]

Hint: Always release locks to avoid deadlocks [OK]

Common Mistakes:

• Thinking race condition occurs despite lock
• Assuming syntax error without checking code
• Believing code is safe without release

5. You design a system where multiple threads update a shared cache. To improve performance, you want to minimize locking time. Which design approach best balances thread safety and performance?

hard

A. Use fine-grained locks for each cache entry

B. Avoid locks and allow unsynchronized updates

C. Use a single global lock for all cache updates

D. Lock the entire cache for every read and write

Solution

1. Step 1: Understand locking strategies

   A single global lock (Use a single global lock for all cache updates) causes contention and slows performance. No locks (Avoid locks and allow unsynchronized updates) risks data corruption. Locking entire cache for reads and writes (Lock the entire cache for every read and write) is too heavy.

2. Step 2: Choose fine-grained locks

   Fine-grained locks (Use fine-grained locks for each cache entry) lock only parts of the cache, reducing waiting time and keeping thread safety.

3. Final Answer:

   Use fine-grained locks for each cache entry -> Option A

4. Quick Check:

   Fine-grained locks = safety + speed [OK]

Hint: Fine-grained locks reduce wait and keep safety [OK]

Common Mistakes:

• Using one big lock causing slowdowns
• Skipping locks causing data errors
• Locking too much causing bottlenecks