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

Puneet Patwari 2026-04-22 16.6 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 --- ## 中文翻译我有12年的工作经验，目前担任首席工程师 [@Atlassian](https://x.com/Atlassian) ，我见过并发让许多初级工程师闻风丧胆。它是系统设计与后端面试中最令人恐惧的主题之一——竞态条件、死锁、线程池……应有尽有。但一旦你真正掌握了这20个必知概念，一切都会豁然开朗。收藏这个帖子，读到最后。你未来的面试和生产系统都会感谢你。 ## 1) 并发多个任务通过在一个CPU（或多个核心）上轮流执行来取得进展。它指的是同时应对多件事情，即使并非真正的同时执行。为什么重要：几乎所有现代后端、移动端或分布式系统都是并发的。如何学习：随便找一个单线程程序，将其重构为使用线程或异步来处理多个请求。可视化执行时间线。 ## 2) 并发 vs 并行并发 = 任务在同一时间段内开始、运行和结束（交错执行）。并行 = 任务在多个核心上同时运行。核心1和核心2在完全相同的时刻执行不同的任务 = 并行。一个核心在任务之间快速切换 = 并发。如何学习：先单线程运行一个CPU密集型任务（如矩阵乘法），然后再多线程运行，并测量实际的加速比。你会立刻看到区别。 ## 3) 进程 vs 线程进程 = 独立的内存空间，更重，通过IPC通信。线程 = 在进程内共享同一内存，更轻量，上下文切换更快。线程共享内存 → 数据共享更容易，但出错风险更高。进程相互隔离 → 更安全，但通信更慢。如何学习：写一个小程序，同时创建一个新进程和多个线程。对比内存占用和通信速度。 ## 4) 线程生命周期 NEW → RUNNABLE → RUNNING → BLOCKED → TERMINATED（有时还有WAITING）。每个线程都会经历的状态机。大多数人忽略的关键状态转换：BLOCKED（等待锁/IO）与 WAITING（显式的等待/通知）。如何学习：使用Java/Python的threading库，在每次状态变化时添加日志。在纸上画出生命周期图，直到能凭记忆复现为止。 ## 5) 竞态条件对共享数据的不同步访问会导致错误结果。经典例子：两个线程同时执行 `x = x + 1` → 最终值出错。这种bug让资深工程师夜不能寐。如何学习：在一个计数器程序中故意制造竞态条件。然后修复它，并在高负载下运行（使用压力测试工具）。 ## 6) 互斥锁同一时间只有一个线程能持有锁，其他线程等待。最基本的同步原语。不用它 → 竞态条件。过度使用 → 性能崩塌。如何学习：使用互斥锁实现一个线程安全的银行账户转账。然后移除锁，实时观察余额变成负数。 ## 7) 信号量互斥锁的泛化。允许N个线程同时访问一个资源（计数信号量）。非常适合限制并发访问（例如数据库连接池）。如何学习：用大小为5的信号量构建一个简单的连接池。用100个线程猛烈访问，观察它始终不超过5个并发连接。 ## 8) 条件变量线程在某个条件上等待，直到另一个线程发出信号。 “就绪时叫醒我”的原语。与互斥锁配合大量使用（wait + signal）。如何学习：使用条件变量实现经典的生产者-消费者问题。这是内化该模式的最佳方式。 ## 9) 粗粒度 vs 细粒度锁粗粒度锁 = 用一把大锁管所有事情（简单但性能差）。细粒度锁 = 使用许多小锁（并行度更高，但复杂度和死锁风险也更高）。简单性与可扩展性之间的权衡。如何学习：拿一个哈希表。先用一把锁保护整个表，然后切换为每个桶一把锁。在高竞争下测量吞吐量。 ## 10) 可重入锁同一线程可以多次获取同一把锁而不会自己死锁。带计数的锁（同一线程锁#1、锁#2 → 仍然持有）。对递归调用或复杂的锁层次结构至关重要。如何学习：分别用普通互斥锁（死锁）和ReentrantLock（正常工作）尝试相同的场景。你永远不会再忘记两者的区别。 ## 11) Try-Lock（尝试加锁）尝试获取锁而不阻塞。如果忙 → 先做其他工作，稍后重试（非阻塞）。非常适合减少热点路径上的竞争。如何学习：用try-lock实现一个缓存。未命中时，尝试获取写锁；如果失败，直接返回旧数据而不是等待。 ## 12) CAS（比较并交换）原子操作：“如果值仍然是X，就把它改为Y”。无锁算法的基础。在现代并发数据结构中无处不在。如何学习：看看Java的AtomicInteger在底层是如何工作的。然后用循环中的CAS实现一个简单的无锁计数器。 ## 13) 死锁两个（或多个）线程各自持有对方需要的锁 → 永久停滞。经典示例：哲学家就餐问题，或“T1持有L1等待L2，T2持有L2等待L1”。如何学习：在代码中复现死锁，然后运用四个Coffman条件系统地打破它。 ## 14) 活锁线程不断相互响应，但没有任何实际进展（就像两个人在走廊里永远互相让路）。比死锁少见，但同样令人抓狂。如何学习：实现两个不断用随机退避重试但仍然相互冲突的线程——然后加入合适的指数退避。 15) 信号模式（类似于生产者-消费者）一个线程（生产者）完成工作并通过条件变量或信号量通知另一个线程（消费者）。大多数并发系统的心跳。如何学习：构建一个任务队列，生产者线程推送工作，消费者线程立即收到通知。 ## 16) 线程池复用一组固定的线程，而不是不断地创建/销毁线程。带来巨大的性能提升，并且能控制并发级别。学习方法：使用 ExecutorService（Java）或 ThreadPoolExecutor，并在高负载下比较创建线程的开销与线程池复用的差异。 ## 17) 生产者-消费者经典模式：生产者向共享缓冲区添加数据，消费者从中取出数据。缓冲区满 → 生产者阻塞。缓冲区空 → 消费者阻塞。学习方法：用 BlockingQueue（Java）实现一次，再用手动锁 + 条件变量实现一次。两种方式都能巩固这一概念。 ## 18) 读写锁允许多个读者同时访问，但写者只能有一个。非常适合读远多于写的场景（例如缓存、配置）。学习方法：为一个共享数据结构添加读写锁，并对读密集型与写密集型工作负载进行基准测试。 ## 19) 线程安全缓存使用读写锁或并发映射（concurrent map）+ 谨慎的失效机制，让多个线程可以安全地读取，同时保证写入的一致性。学习方法：构建一个简单的线程安全 LRU 缓存。然后添加淘汰机制，看看没有适当的同步时问题会多快出现。 ## 20) 阻塞队列一种线程安全队列，满时阻塞生产者，空时阻塞消费者。它是大多数生产者-消费者实现和线程池的基石。学习方法：使用锁 + 条件变量自己实现一个 BlockingQueue，然后切换到语言自带的实现并进行比较。掌握并发不在于死记 API，而在于理解各种权衡，并能在压力下进行调试。这 20 个概念覆盖了你在真实系统和面试中会遇到的问题的 95%。掌握它们，你就会成为那个真正能交付可靠并发代码的工程师。如果你想在这些系统设计基础（以及其他 90+ 个主题）上变得更强，我专为资深（Senior）→ 首席（Principal）工程师打造了一份完整的指南。请在这里查看：[https://puneetpatwari.in](https://t.co/MGA7m8eKw3) 在过去 6 个月里，我指导了 100 位中级、高级和资深工程师备战系统设计面试，这个问题有 80% 的时间都会出现。这是我经过实践检验的方法，能帮助你跨越学习旅程中的这个阶段： ![](/doc/947/image/img_537cc2b78198.jpg) 很高兴知道…… 是的，完全正确。而且现在随着 AI 的发展，更多的抽象层正在涌现。但我们仍然应该精通基础原理。