后端工程师必知的20个并发编程核心概念

✍ Puneet Patwari🕐 2026-04-22📦 8.2 KB 🟢 已读 𝕏 文章列表

Atlassian 首席工程师总结的后端面试与系统设计中的 20 个并发编程核心概念。文章涵盖了从基础的并发与并行、进程线程区别，到互斥锁、信号量、死锁、CAS、线程池及生产者-消费者模式等进阶主题。旨在帮助工程师掌握并发原语，理解性能权衡，从而构建可靠的生产级系统。

并发编程多线程系统设计后端面试锁机制死锁性能优化线程池算法

I have 12 years of experience and working as a Principal Engineer [@Atlassian](https://x.com/Atlassian) and I have seen concurrency scaring the hell out of a lot of junior engineers. It’s one of the most feared topics in system design & backend interviews — race conditions, deadlocks, thread pools… you name it. But once you internalize these 20 must-know concepts, everything clicks. Save this thread. Read till the end. Your future interviews and production systems will thank you. ## 1) Concurrency Multiple tasks make progress by taking turns on one CPU (or across cores). It’s about dealing with many things at once, even if not truly simultaneous. Why it matters: Almost every modern backend, mobile, or distributed system is concurrent. How to learn it: Take any single-threaded program and refactor it to handle multiple requests using threads or async. Visualize the timeline of execution. ## 2) Concurrency vs Parallelism Concurrency = tasks start, run, and end within the same period (interleaved). Parallelism = tasks run simultaneously on multiple cores. Core 1 and Core 2 running different things at the exact same time = Parallel. One core switching between tasks quickly = Concurrent. How to learn it: Run a CPU-bound task (e.g. matrix multiplication) first single-threaded, then multi-threaded, and measure real speedup. You’ll see the difference immediately. ## 3) Processes vs Threads Processes = isolated memory space, heavier, communicate via IPC. Threads = share the same memory within a process, lighter, faster context switch. Threads share memory → easier data sharing but more risk of bugs. Processes are isolated → safer but slower communication. How to learn it: Write a small program that spawns both a new process and multiple threads. Compare memory usage and communication speed. ## 4) Thread Lifecycle NEW → RUNNABLE → RUNNING → BLOCKED → TERMINATED (and sometimes WAITING). The state machine every thread goes through. Key transition most people miss: BLOCKED (waiting for lock/I/O) vs WAITING (explicit wait/notify). How to learn it: Use Java/Python’s threading library and add logging at every state change. Draw the lifecycle diagram on paper until you can reproduce it from memory. ## 5) Race Condition Un-synchronized access to shared data leads to incorrect results. Classic example: Two threads do `x = x + 1` at the same time → final value is wrong. The bug that keeps senior engineers up at night. How to learn it: Intentionally create a race condition in a counter program. Then fix it and run it under load (use stress testing tools). ## 6) Mutex (Mutual Exclusion) Only one thread can hold the lock at a time. Others wait. The most basic synchronization primitive. If you don’t use it → race conditions. If you overuse it → performance dies. How to learn it: Implement a thread-safe bank account transfer using mutex. Then remove the lock and watch the balance go negative in real time. ## 7) Semaphore Generalization of mutex. Allows N threads to access a resource at once (counting semaphore). Perfect for limiting concurrent access (e.g., database connection pool). How to learn it: Build a simple connection pool with a semaphore of size 5. Hammer it with 100 threads and watch it never exceed 5 concurrent connections. ## 8) Condition Variables Thread waits on a condition until another thread signals it. The “wake me up when ready” primitive. Used heavily with mutexes (wait + signal). How to learn it: Implement the classic Producer-Consumer problem using condition variables. It’s the best way to internalize the pattern. ## 9) Coarse vs Fine-grained Locking Coarse lock = one big lock for everything (simple but poor performance). Fine-grained lock = many small locks (more parallelism but higher complexity & deadlock risk). Trade-off between simplicity and scalability. How to learn it: Take a hashmap. First protect the entire map with one lock, then switch to per-bucket locks. Measure throughput under high contention. ## 10) Reentrant Lock Same thread can acquire the same lock multiple times without deadlocking itself. Counted lock (lock #1, lock #2 on same thread → still holds). Critical for recursive calls or complex lock hierarchies. How to learn it: Try the same scenario with a normal mutex (deadlock) vs ReentrantLock (works). You’ll never forget the difference. ## 11) Try-Lock Attempt to acquire a lock without blocking. If busy → do other work and retry later (non-blocking). Great for reducing contention in hot paths. How to learn it: Implement a cache with try-lock. On miss, try to acquire write lock; if fails, just return stale data instead of waiting. ## 12) CAS (Compare-And-Swap) Atomic operation: “If value is still X, change it to Y”. The foundation of lock-free algorithms. Used everywhere in modern concurrent data structures. How to learn it: Look at how Java’s AtomicInteger works under the hood. Then implement a simple lock-free counter using CAS in a loop. ## 13) Deadlock Two (or more) threads each hold a lock the other needs → permanent stall. Classic dining philosophers or “T1 holds L1 waits for L2, T2 holds L2 waits for L1”. How to learn it: Reproduce deadlock in code, then apply the 4 Coffman conditions to break it systematically. ## 14) Livelock Threads keep responding to each other but make no actual progress (like two people stepping aside in a corridor forever). Less common than deadlock but equally frustrating. How to learn it: Implement two threads that keep retrying with random backoff but still collide — then add proper exponential backoff. 15) Signaling Pattern (similar to Producer-Consumer) One thread (producer) does work and signals another (consumer) via condition variable or semaphore. The heartbeat of most concurrent systems. How to learn it: Build a task queue where producer threads push work and consumer threads get notified instantly. ## 16) Thread Pool Reuse a fixed set of threads instead of creating/destroying them constantly. Massive performance win + controls concurrency level. How to learn it: Use ExecutorService (Java) or ThreadPoolExecutor and compare creation overhead vs pool reuse under heavy load. ## 17) Producer-Consumer Classic pattern: producers add to a shared buffer, consumers remove. Buffer full → producers block. Buffer empty → consumers block. How to learn it: Implement it with BlockingQueue (Java) and with manual locks + condition variables. Both ways cement the concept. ## 18) Reader-Writer Lock Multiple readers allowed at once, but only one writer. Perfect when reads >> writes (e.g. cache, config). How to learn it: Add a reader-writer lock to a shared data structure and benchmark read-heavy vs write-heavy workloads. ## 19) Thread-Safe Cache Use read-write locks or concurrent map + careful invalidation so multiple threads can read safely while writes stay consistent. How to learn it: Build a simple LRU cache that is thread-safe. Then add eviction and see how quickly things break without proper synchronization. ## 20) Blocking Queue Thread-safe queue that blocks producers when full and consumers when empty. The backbone of most producer-consumer implementations and thread pools. How to learn it: Implement your own BlockingQueue using locks + condition variables, then switch to the language-provided one and compare. Concurrency mastery isn’t about memorizing APIs instead it’s about understanding the trade-offs and being able to debug under pressure. These 20 concepts cover 95% of what you’ll face in real systems and interviews. Master them and you’ll stand out as the engineer who actually ships reliable concurrent code. If you want to get stronger at these system design fundamentals (and 90+ others), I’ve built a complete guide exactly for Senior → Principal engineers. Check it out here: [https://puneetpatwari.in](https://t.co/MGA7m8eKw3) In the last 6 months, I've coached 100 Mid-level, Senior and Staff level engineers on system design interviews and this has come up 80% of the time. This is my tried and tested way to get over this phase in your learning journey: ![](/doc/947/image/img_537cc2b78198.jpg) Glad to know.. Yes absolutely. And now with AI more abstractions are coming in. Still we should be well versed with the fundamentals

🔗 相关文档