Course contentsShow
← Computer Science
Lesson 2577 of 2,87257. Concurrency FundamentalsFree lesson

Lock-Based vs Lock-Free Approaches

Comparing coarse-grained locking, fine-grained locking, and lock-free techniques for concurrent data structures.

Lock-Based vs Lock-Free Approaches

You'll learn: How to choose between using locks, fine-grained locking, or lock-free techniques when building concurrent data structures.

When multiple threads access shared data structures, you have three main architectural strategies to ensure thread safety.

Coarse-Grained Locking

The simplest approach: wrap the entire data structure with a single lock. Every operation—read or write—acquires this lock, does its work, then releases it. This is like having one key for an entire building: only one person can be inside at any time. It's easy to reason about and implement, but creates a bottleneck—threads wait in line even when they could safely work on different parts of the structure.

Fine-Grained Locking

This strategy uses multiple locks for different parts of the data structure. For example, a hash table might have one lock per bucket. Think of it as having separate keys for different rooms in a building: multiple people can work simultaneously if they're in different rooms. This reduces contention but increases complexity—you must carefully manage lock ordering to avoid deadlocks.

Lock-Free Approaches

These use atomic operations like compare-and-swap instead of locks. Threads attempt updates optimistically, retrying if another thread interfered. There's no waiting—threads always make progress, though some may need multiple attempts. This is like a note-passing system where everyone can read anytime, and writes succeed only if no one else changed things first.

Trade-offs: Coarse-grained locking is simple but slow under contention. Fine-grained locking improves throughput but complicates design. Lock-free techniques maximize concurrency and eliminate deadlocks but are harder to implement correctly and may suffer from the ABA problem or memory reclamation challenges.

Key Takeaway: Choose coarse-grained locking for simplicity, fine-grained for moderate contention with manageable complexity, and lock-free when maximum concurrency justifies the implementation difficulty.