Write a thread-safe Singleton
💡 Concept: Thread-safe Singleton
A thread-safe Singleton ensures only one instance is created even in multithreaded environments.
📘 Quick Intro
This pattern uses synchronization techniques to avoid multiple instance creation in concurrent threads.
🧠 Analogy
Imagine a single cashier serving customers in a busy store, ensuring only one is active at a time.
🔧 Technical Explanation
- Use locks or Lazy<T> to synchronize instance creation.
- Double-checked locking reduces overhead by locking only when necessary.
- Ensures consistency and avoids race conditions.
- Improves application stability in multithreaded contexts.
🎯 Use Cases
- ✅ Configuration managers
- ✅ Logging classes
- ✅ Caching providers
- ✅ Resource management in multithreaded apps
💻 Code Example
// Thread-safe Singleton with double-checked locking
public sealed class ThreadSafeSingleton {
private static ThreadSafeSingleton instance = null;
private static readonly object lockObj = new object();
private ThreadSafeSingleton() {
// Private constructor
}
public static ThreadSafeSingleton Instance {
get {
if (instance == null) {
lock (lockObj) {
if (instance == null) {
instance = new ThreadSafeSingleton();
}
}
}
return instance;
}
}
public void DoWork() {
Console.WriteLine(""Thread-safe Singleton working."");
}
}
❓ Interview Q&A
Q1: Why is thread safety important in Singleton?
A: To prevent multiple instances in concurrent access.
Q2: What is double-checked locking?
A: Optimizes locking by checking instance before and after lock.
Q3: Can Lazy<T> replace locks?
A: Yes, it provides thread-safe lazy initialization.
Q4: Is the constructor public?
A: No, it is private to prevent external instantiation.
Q5: What is the lock object?
A: An object used to synchronize access.
Q6: Can this pattern impact performance?
A: Slightly during locking but optimized with double-check.
Q7: How to call the singleton instance?
A: Via the static Instance property.
Q8: Is the class sealed?
A: Usually to prevent inheritance.
Q9: What problems does it solve?
A: Race conditions and inconsistent state.
Q10: Where is this pattern commonly used?
A: Multithreaded applications requiring single shared instances.
📝 MCQs
Q1. What is the purpose of double-checked locking?
- Eliminate locking
- Optimize locking performance
- Delay locking
- Increase locking
Q2. Why is the constructor private?
- Allow inheritance
- Prevent external instantiation
- Make class abstract
- Enable static methods
Q3. What does the lock object do?
- Creates instance
- Synchronizes access
- Prevents garbage collection
- Handles exceptions
Q4. Can Lazy<T> replace double-checked locking?
- No
- Yes
- Sometimes
- Rarely
Q5. Is the Singleton class sealed?
- No
- Usually yes
- Sometimes
- Never
Q6. How is thread safety ensured?
- Using locks or Lazy<T>
- Ignoring threads
- Using timers
- Using async/await
Q7. What is the impact on performance?
- Severe
- Minimal with optimization
- Moderate
- None
Q8. How do you access the Singleton instance?
- New keyword
- Via static Instance property
- Via instance method
- Direct constructor call
Q9. Why use Singleton pattern?
- Avoid it
- Control instance creation
- Improve UI
- Handle exceptions
Q10. What problem does this solve?
- Memory leaks
- Race conditions
- Slow startup
- Garbage collection
💡 Bonus Insight
The thread-safe Singleton pattern prevents race conditions in multithreaded applications ensuring one consistent instance.
📄 PDF Download
Need a handy summary for your notes? Download this topic as a PDF!