Multithreading

Concurrency, parallelism, and thread-safe programming, as they actually get asked in senior interviews.

Everything here answers one question wearing different costumes: who is allowed to proceed, and who tells them? Start with the 101 to get the vocabulary, learn the framework to get a repeatable method, then work the ten pattern families. The problems under each pattern are there to be solved, not read.

Start here

• Multithreading 101: everything you must know. The concepts, the JMM, the primitives, the failure catalog. One page, no problems, all vocabulary.
• What do you actually do in a Multithreading interview?. Classify → invariant → pattern → template → verify, in 45 minutes.

Patterns

Ten families cover every concurrency question I’ve seen asked. Each playbook has the mechanics, the derivation recipe, and the failure modes; each problem below it is a worked application.

Families 1 to 7 are the coordination core, learn these first and in order. Families 8 to 10 are the senior material: what correctness costs at scale, whether you can find someone else’s bug, and whether your instincts survive the process boundary.

The coordination core

• Ordering & Turn-Taking. The baton: who acts next, who hands it over
  • Problems
    • Print in Order
    • Print FooBar Alternately
    • Print Zero Even Odd
    • Odd-Even Printer
    • FizzBuzz Multithreaded
    • N Threads Round-Robin
• Guarded State & Mutual Exclusion. One invariant, one lock, and the check-then-act disease
  • Problems
    • Thread-Safe Singleton
    • Dining Philosophers
    • Make a Class Thread-Safe
    • Traffic Light Intersection
    • Circuit Breaker
• Bounded Resource & Producer-Consumer. Two parties waiting on opposite predicates
  • Problems
    • Bounded Blocking Queue
    • Thread Pool from Scratch
    • Connection Pool
    • Bulkhead Isolation
    • Implement a Semaphore
    • Implement CountDownLatch or CyclicBarrier
    • Dining Savages
    • The Barbershop
    • In-Memory SQS-Like Queue
• Group Formation & Barriers. Admission and boundary, kept separate
  • Problems
    • Reusable Barrier
    • Building H2O
    • The Uber Ride Problem
    • River Crossing
    • Roller Coaster
• Asymmetric Access & Readers-Writers. The lightswitch, and choosing who starves
  • Problems
    • Reader-Writer Lock
    • The Unisex Bathroom
    • Search-Insert-Delete
• Task Lifecycle, Async & Parallelism. Where is the work, and who is counting it
  • Problems
    • Multithreaded Web Crawler
    • DAG Task Scheduler
    • Event Bus with Per-Key Ordering
    • Parallel API Aggregation
    • Fork-Join Parallel Computation
    • Implement a Future/Promise
    • Multithreaded Merge Sort
    • Topic-Based Pub/Sub Broker (Kafka-lite)
• Time-Based State. State as a function of the clock
  • Problems
    • Token Bucket Rate Limiter
    • Delayed Task Scheduler
    • Read-Heavy Cache with Expiry
    • Retry with Backoff and Jitter
    • Batching Aggregator
    • Single-Flight Cache Refresh (Thundering Herd)

The senior material

• Concurrent Data Structures. Guarded state with a throughput requirement: does the invariant decompose?
  • Problems
    • Thread-Safe LRU Cache
    • Lock Striping & ConcurrentHashMap
    • Lock-Free Stack (Treiber)
    • Lock-Free & Bounded Queues
    • Striped Counter / LongAdder
    • Copy-on-Write Snapshot Registry
    • Concurrent Stock Exchange (Matching Engine)
    • Thread-Safe Leaderboard
    • Thread-Safe RandomizedSet
• Debugging & Code Review. Run the method backwards: symptom → cause → proof
  • Problems
    • The Lost Update Hunt
    • The Hang That Isn’t a Deadlock
    • Lock-Order Inversion Review
    • The Visibility Bug
    • Check-Then-Act on a Concurrent Map
    • Executor Misuse Review
• Distributed Concurrency & Idempotency. The same problems with no shared memory and partial failure
  • Problems
    • Idempotency Keys
    • Optimistic Concurrency Control
    • Pessimistic Locking & Isolation Levels
    • Distributed Locks & Leases
    • Exactly-Once Processing
    • Flash-Sale Inventory
    • Double-Booking Prevention
    • Distributed Rate Limiter

How to use this

Read the problem statement, close the page, and try it for 15–20 minutes in a blank editor. Only then read the strategy. The strategy pages deliberately contain no full solutions. They give you the invariant, the mental model, and the failure modes, so you reconstruct the code from understanding rather than recall. If you can’t rederive it a week later, you memorized it.

Two families break that loop on purpose. In Debugging & Code Review there is nothing to code first: the diagnosis is the deliverable, so work aloud from symptom to hypothesis to reproduction to fix before opening the strategy. In Distributed Concurrency these are spoken design answers: always give the single-JVM answer first, in code-level detail, and name its linearization point before you name any datastore. That ordering is itself part of what gets graded.

← Back to Interview Prep