{"title":"CountdownLatch Pattern","description":null,"content":"# CountDownLatch Pattern Explained\n\nYour application starts up. It needs to initialize three services: database connection, cache warming, and configuration loading. The main thread can't start accepting requests until all three are ready. But you want them to initialize in parallel for faster startup.\n\nHow do you make the main thread wait for exactly three events to complete?\n\nYou could use a counter protected by a lock. Each service decrements the counter when done. The main thread loops, checking if the counter hit zero. But this is inefficient (busy waiting) and error-prone (what if you forget to decrement?).\n\nThe **CountDownLatch Pattern** solves this elegantly. It's a synchronization primitive that allows one or more threads to wait until a set of operations completes. You initialize it with a count, threads decrement it as they finish, and waiting threads are released when the count reaches zero.\n\nIn this article, we'll explore:\n\n- What is a CountDownLatch?\n- The problem it solves\n- How it works internally\n- Implementation from scratch\n- Common use cases\n- CountDownLatch vs CyclicBarrier\n- Common pitfalls\n- Interview applications\n\n---\n\nIf you're enjoying this newsletter and want to get even more value, consider becoming a **[paid subscriber](https://blog.algomaster.io/subscribe)**.\n\nAs a paid subscriber, you'll unlock all **premium articles** and gain full access to all **[premium courses](https://algomaster.io/newsletter/paid/resources)** on **[algomaster.io](https://algomaster.io)**.\n\n[Unlock Full Access](undefined)\n\n---\n\n## 1. What is a CountDownLatch?\n\nA **CountDownLatch** is a synchronization aid that allows one or more threads to wait until a set of operations being performed by other threads completes. It's initialized with a count. Threads call `countDown()` to decrement the count, and threads call `await()` to block until the count reaches zero.\n\n\n```mermaid\nflowchart TD\n subgraph Workers[\"Worker Threads\"]\n W1[Worker 1]:::primary\n W2[Worker 2]:::primary\n W3[Worker 3]:::primary\n end\n\n L[CountDownLatch
count: 3]:::orange\n\n W1 -->|countDown| L\n W2 -->|countDown| L\n W3 -->|countDown| L\n\n L -->|\"await() returns
when count = 0\"| M[Main Thread]:::green\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nKey characteristics:\n\n1. **One-time use:** Once the count reaches zero, it stays at zero. The latch cannot be reset.\n2. **Non-blocking signal:** `countDown()` doesn't block. It just decrements and returns.\n3. **Blocking wait:** `await()` blocks until count reaches zero.\n4. **Multiple waiters:** Any number of threads can wait on the same latch.\n\nThink of it as a gate that opens when a certain number of events occur. Once open, it stays open forever.\n\n---\n\n## 2. The Problem: Waiting for Multiple Events\n\n### Scenario 1: Service Initialization\n\nA web server needs multiple components ready before accepting traffic:\n\n\n```mermaid\nflowchart TD\n subgraph Init[\"Initialization (parallel)\"]\n DB[Database Pool]:::primary\n Cache[Cache Warmer]:::primary\n Config[Config Loader]:::primary\n end\n\n Server[Start Server]:::green\n\n DB -->|ready| Server\n Cache -->|ready| Server\n Config -->|ready| Server\n\n Note[Server must wait for ALL]:::orange\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nWithout proper synchronization:\n\n- Server might start before database is ready → connection failures\n- Server might start before cache is warm → slow initial requests\n- Server might start before config loads → missing configuration\n\n### Scenario 2: Parallel Test Execution\n\nYou want to test concurrent behavior. Multiple test threads should start simultaneously:\n\n\n```mermaid\nflowchart LR\n subgraph Setup[\"Setup Phase\"]\n T1[Thread 1
ready]:::primary\n T2[Thread 2
ready]:::primary\n T3[Thread 3
ready]:::primary\n end\n\n Gate[Start Signal]:::orange\n\n subgraph Run[\"Execution Phase\"]\n R1[Thread 1
running]:::green\n R2[Thread 2
running]:::green\n R3[Thread 3
running]:::green\n end\n\n T1 --> Gate\n T2 --> Gate\n T3 --> Gate\n Gate --> R1\n Gate --> R2\n Gate --> R3\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nIf threads start at different times, you're not testing true concurrency.\n\n### Scenario 3: Batch Processing Completion\n\nA coordinator dispatches work to multiple workers and needs to know when all are done:\n\n\n```mermaid\nflowchart TD\n C[Coordinator]:::primary -->|dispatch| W1[Worker 1]:::orange\n C -->|dispatch| W2[Worker 2]:::orange\n C -->|dispatch| W3[Worker 3]:::orange\n C -->|dispatch| W4[Worker 4]:::orange\n\n W1 -->|done| R[Results Ready]:::green\n W2 -->|done| R\n W3 -->|done| R\n W4 -->|done| R\n\n R --> A[Aggregate Results]:::purple\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef purple fill:#9775fa,stroke:#000,color:#000\n```\n\n\n### Why Not Use Other Approaches?\n\n\n| ##### Approach | ##### Problem |\n| --- | --- |\n| Busy waiting loop | Wastes CPU cycles |\n| Thread.join() | Only works for threads you created |\n| Single condition variable | Hard to count multiple events |\n| Multiple flags | Race conditions, complex logic |\n\n\nCountDownLatch provides a clean, efficient solution.\n\n---\n\n## 3. How CountDownLatch Works\n\n### The Core Mechanics\n\nA CountDownLatch maintains:\n\n1. **Count:** Number of events still expected\n2. **Wait queue:** Threads blocked on `await()`\n\n\n```mermaid\nflowchart TD\n subgraph Latch[\"CountDownLatch State\"]\n C[count = 3]:::orange\n Q[Wait Queue:
Thread A, Thread B]:::secondary\n end\n\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef secondary fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### Operation: countDown()\n\n\n```mermaid\nflowchart TD\n A[countDown called]:::primary --> B{count > 0?}\n B -->|Yes| C[count = count - 1]:::orange\n C --> D{count == 0?}\n D -->|Yes| E[Wake all waiting threads]:::green\n D -->|No| F[Return]:::secondary\n B -->|No| F\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef secondary fill:#38d9a9,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\n`countDown()` is non-blocking. It decrements and returns immediately. If the count reaches zero, it wakes all waiting threads.\n\n### Operation: await()\n\n\n```mermaid\nflowchart TD\n A[await called]:::primary --> B{count == 0?}\n B -->|Yes| C[Return immediately]:::green\n B -->|No| D[Add to wait queue]:::orange\n D --> E[Block thread]:::orange\n E --> F[Woken up]:::secondary\n F --> C\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef secondary fill:#38d9a9,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\n`await()` blocks if count > 0. When count reaches zero, all waiting threads wake up and return.\n\n### Complete Flow Example\n\n\n```mermaid\nsequenceDiagram\n participant M as Main Thread\n participant L as Latch (count=3)\n participant W1 as Worker 1\n participant W2 as Worker 2\n participant W3 as Worker 3\n\n M->>L: await()\n Note over M: Blocked (count=3)\n\n W1->>W1: Do work\n W1->>L: countDown()\n Note over L: count = 2\n\n W3->>W3: Do work\n W3->>L: countDown()\n Note over L: count = 1\n\n W2->>W2: Do work\n W2->>L: countDown()\n Note over L: count = 0\n\n L-->>M: Wake up!\n Note over M: Continues execution\n```\n\n\nNotice that workers complete in any order. The latch doesn't care about order, only that the count reaches zero.\n\n---\n\n## 4. Implementation from Scratch\n\n### Basic Implementation\n\n\n```java\npublic class CountDownLatch {\n private int count;\n private final Object lock = new Object();\n\n public CountDownLatch(int count) {\n if (count < 0) throw new IllegalArgumentException(\"count < 0\");\n this.count = count;\n }\n\n public void await() throws InterruptedException {\n synchronized (lock) {\n while (count > 0) {\n lock.wait();\n }\n }\n }\n\n public void countDown() {\n synchronized (lock) {\n if (count > 0) {\n count--;\n if (count == 0) {\n lock.notifyAll();\n }\n }\n }\n }\n\n public int getCount() {\n synchronized (lock) {\n return count;\n }\n }\n}\n```\n\n\n### Adding Timeout Support\n\nOften you don't want to wait forever:\n\n\n```java\npublic boolean await(long timeout, TimeUnit unit) throws InterruptedException {\n long remainingNanos = unit.toNanos(timeout);\n long deadline = System.nanoTime() + remainingNanos;\n\n synchronized (lock) {\n while (count > 0) {\n if (remainingNanos <= 0) {\n return false; // Timeout\n }\n // Wait with timeout (convert nanos to millis)\n lock.wait(remainingNanos / 1_000_000);\n remainingNanos = deadline - System.nanoTime();\n }\n return true; // Count reached zero\n }\n}\n```\n\n\n### Why notifyAll() Instead of notify()?\n\nMultiple threads might be waiting on the latch. `notify()` only wakes one thread. `notifyAll()` ensures all waiters are released when the count hits zero.\n\n\n```mermaid\nflowchart TD\n subgraph Waiters[\"Multiple Waiters\"]\n T1[Thread A
await]:::primary\n T2[Thread B
await]:::primary\n T3[Thread C
await]:::primary\n end\n\n L[Latch
count → 0]:::orange\n\n L -->|notifyAll| T1\n L -->|notifyAll| T2\n L -->|notifyAll| T3\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\n---\n\n## 5. Common Use Cases\n\n### Use Case 1: Service Initialization\n\nWait for all services to initialize before starting the application:\n\n\n```java\npublic class Application {\n public static void main(String[] args) throws InterruptedException {\n int serviceCount = 3;\n CountDownLatch latch = new CountDownLatch(serviceCount);\n\n // Start services in parallel\n new Thread(() -> {\n initializeDatabase();\n latch.countDown();\n }).start();\n\n new Thread(() -> {\n warmCache();\n latch.countDown();\n }).start();\n\n new Thread(() -> {\n loadConfig();\n latch.countDown();\n }).start();\n\n // Wait for all services\n latch.await();\n System.out.println(\"All services ready. Starting server...\");\n startServer();\n }\n}\n```\n\n\n\n```mermaid\nflowchart TD\n subgraph Parallel[\"Parallel Initialization\"]\n DB[Init Database]:::primary\n Cache[Warm Cache]:::primary\n Config[Load Config]:::primary\n end\n\n L[Latch: 3 → 0]:::orange\n\n DB -->|countDown| L\n Cache -->|countDown| L\n Config -->|countDown| L\n\n L -->|await returns| S[Start Server]:::green\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\n### Use Case 2: Starting Gun Pattern\n\nAll threads should start working at exactly the same time:\n\n\n```java\npublic class RaceSimulation {\n public void runRace(int runnerCount) throws InterruptedException {\n CountDownLatch startGun = new CountDownLatch(1); // Single signal\n CountDownLatch finish = new CountDownLatch(runnerCount);\n\n for (int i = 0; i < runnerCount; i++) {\n int runnerId = i;\n new Thread(() -> {\n try {\n prepareRunner(runnerId);\n startGun.await(); // Wait for start signal\n runRace(runnerId);\n } finally {\n finish.countDown();\n }\n }).start();\n }\n\n Thread.sleep(1000); // Let all runners prepare\n System.out.println(\"GO!\");\n startGun.countDown(); // Release all runners simultaneously\n\n finish.await(); // Wait for all to finish\n System.out.println(\"Race complete!\");\n }\n}\n```\n\n\n\n```mermaid\nflowchart TD\n subgraph Prepare[\"Preparation Phase\"]\n R1[Runner 1
await startGun]:::primary\n R2[Runner 2
await startGun]:::primary\n R3[Runner 3
await startGun]:::primary\n end\n\n G[Start Gun
count: 1]:::orange\n\n subgraph Run[\"Running Phase\"]\n R1R[Runner 1
running]:::green\n R2R[Runner 2
running]:::green\n R3R[Runner 3
running]:::green\n end\n\n R1 --> G\n R2 --> G\n R3 --> G\n\n G -->|\"countDown()\"| R1R\n G -->|simultaneous| R2R\n G -->|release| R3R\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThis pattern uses a latch with count=1. All threads wait on it. A single `countDown()` releases everyone simultaneously.\n\n### Use Case 3: Test Coordination\n\nEnsure concurrent test threads start together and finish before assertions:\n\n\n```java\npublic class ConcurrencyTest {\n @Test\n public void testConcurrentAccess() throws InterruptedException {\n int threadCount = 10;\n CountDownLatch ready = new CountDownLatch(threadCount);\n CountDownLatch start = new CountDownLatch(1);\n CountDownLatch done = new CountDownLatch(threadCount);\n\n SharedResource resource = new SharedResource();\n\n for (int i = 0; i < threadCount; i++) {\n new Thread(() -> {\n ready.countDown(); // Signal ready\n try {\n start.await(); // Wait for start signal\n resource.access(); // The actual test\n } finally {\n done.countDown(); // Signal completion\n }\n }).start();\n }\n\n ready.await(); // Wait for all threads to be ready\n start.countDown(); // Start all threads\n done.await(); // Wait for all to complete\n\n // Now safe to make assertions\n assertEquals(expected, resource.getState());\n }\n}\n```\n\n\n\n```mermaid\nflowchart LR\n subgraph Phase1[\"Phase 1: Setup\"]\n T1[Thread 1]:::primary\n T2[Thread 2]:::primary\n TN[Thread N]:::primary\n end\n\n R[Ready Latch
count: N]:::orange\n S[Start Latch
count: 1]:::orange\n D[Done Latch
count: N]:::orange\n\n subgraph Phase2[\"Phase 2: Execute\"]\n E1[Execute]:::secondary\n E2[Execute]:::secondary\n EN[Execute]:::secondary\n end\n\n A[Assert Results]:::green\n\n T1 -->|ready.countDown| R\n T2 -->|ready.countDown| R\n TN -->|ready.countDown| R\n\n R -->|await| S\n S -->|countDown| E1\n S -->|countDown| E2\n S -->|countDown| EN\n\n E1 -->|done.countDown| D\n E2 -->|done.countDown| D\n EN -->|done.countDown| D\n\n D -->|await| A\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef secondary fill:#38d9a9,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThis three-latch pattern is powerful for testing:\n\n1. **Ready latch:** Ensures all threads are initialized\n2. **Start latch:** Triggers simultaneous execution\n3. **Done latch:** Ensures all threads complete before assertions\n\n### Use Case 4: Parallel Task Completion\n\nWait for N parallel tasks to complete:\n\n\n```java\npublic class ParallelProcessor {\n public List processInParallel(List tasks) throws InterruptedException {\n CountDownLatch latch = new CountDownLatch(tasks.size());\n List results = Collections.synchronizedList(new ArrayList<>());\n\n for (Task task : tasks) {\n executor.submit(() -> {\n try {\n Result result = process(task);\n results.add(result);\n } finally {\n latch.countDown();\n }\n });\n }\n\n latch.await(); // Wait for all tasks\n return results;\n }\n}\n```\n\n\n### Use Case 5: Graceful Shutdown\n\nWait for all workers to finish before shutting down:\n\n\n```java\npublic class WorkerPool {\n private final CountDownLatch shutdownLatch;\n private volatile boolean shuttingDown = false;\n\n public WorkerPool(int workerCount) {\n this.shutdownLatch = new CountDownLatch(workerCount);\n\n for (int i = 0; i < workerCount; i++) {\n new Thread(() -> {\n while (!shuttingDown) {\n processNextTask();\n }\n shutdownLatch.countDown();\n }).start();\n }\n }\n\n public void shutdown() throws InterruptedException {\n shuttingDown = true;\n shutdownLatch.await(30, TimeUnit.SECONDS);\n System.out.println(\"All workers stopped\");\n }\n}\n```\n\n\n---\n\n## 6. CountDownLatch vs CyclicBarrier\n\nBoth synchronize multiple threads, but they serve different purposes.\n\n\n```mermaid\nflowchart TD\n subgraph CDL[\"CountDownLatch\"]\n W1[Worker]:::primary -->|countDown| L[Latch]:::orange\n W2[Worker]:::primary -->|countDown| L\n W3[Worker]:::primary -->|countDown| L\n L -->|await| M[Main Thread
waiting]:::green\n end\n\n subgraph CB[\"CyclicBarrier\"]\n T1[Thread]:::primary -->|await| B[Barrier]:::orange\n T2[Thread]:::primary -->|await| B\n T3[Thread]:::primary -->|await| B\n B -->|released| T1R[All continue]:::green\n B -->|released| T2R[All continue]:::green\n B -->|released| T3R[All continue]:::green\n end\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\n### Key Differences\n\n\n| ##### Feature | ##### CountDownLatch | ##### CyclicBarrier |\n| --- | --- | --- |\n| **Reusability** | One-time use | Reusable (cyclic) |\n| **Who waits** | Any thread(s) | The threads that count |\n| **Who counts** | Different threads decrement | Same threads that wait |\n| **countDown blocks?** | No, returns immediately | await() blocks |\n| **Multiple events per thread** | Yes, can countDown multiple times | No, one await per cycle |\n| **Reset** | Cannot reset | Auto-resets after trip |\n\n\n### Mental Model\n\n**CountDownLatch:** Waiting for N events to happen\n\n- \"Wait until 3 files are downloaded\"\n- \"Wait until 5 services are ready\"\n- Events can come from anywhere\n\n**CyclicBarrier:** N threads meeting at a point\n\n- \"All 4 threads must reach this point before continuing\"\n- \"Sync between phases of a parallel algorithm\"\n- Same threads that wait also signal\n\n### Analogy\n\n**CountDownLatch:** A door that opens when N keys are inserted. Anyone can insert a key. Once open, it stays open. Different people can insert keys than those waiting to enter.\n\n**CyclicBarrier:** A meeting room that requires N people. Everyone waits at the door. When all N arrive, everyone enters together. After the meeting, the room resets for the next meeting.\n\n### Code Comparison\n\n\n```java\n// CountDownLatch: Different threads wait vs signal\nCountDownLatch latch = new CountDownLatch(3);\n\n// Worker threads (don't wait)\nworkers.forEach(w -> {\n w.doWork();\n latch.countDown(); // Doesn't block\n});\n\n// Main thread (waits)\nlatch.await(); // Blocks until count = 0\n```\n\n\n\n```java\n// CyclicBarrier: Same threads wait and signal\nCyclicBarrier barrier = new CyclicBarrier(3);\n\n// Each thread both signals AND waits\nthreads.forEach(t -> {\n t.doPhase1Work();\n barrier.await(); // Signal AND wait\n t.doPhase2Work();\n barrier.await(); // Can reuse!\n});\n```\n\n\n### When to Use Which\n\n\n| ##### Scenario | ##### Use |\n| --- | --- |\n| Main thread waits for workers | CountDownLatch |\n| One-time initialization sync | CountDownLatch |\n| Starting gun (release all at once) | CountDownLatch(1) |\n| Parallel algorithm phases | CyclicBarrier |\n| Threads sync repeatedly | CyclicBarrier |\n| Same threads signal and wait | CyclicBarrier |\n\n\n---\n\n## 7. Common Pitfalls\n\n### Pitfall 1: Forgetting to countDown\n\nIf a thread fails to call `countDown()`, waiters block forever:\n\n\n```java\n// BUG: Exception prevents countDown\nnew Thread(() -> {\n initializeService(); // Might throw!\n latch.countDown(); // Never reached if exception\n}).start();\n\nlatch.await(); // Blocks forever if any thread fails\n```\n\n\n**Solution:** Use try-finally:\n\n\n```java\nnew Thread(() -> {\n try {\n initializeService();\n } finally {\n latch.countDown(); // Always executes\n }\n}).start();\n```\n\n\n### Pitfall 2: Wrong Count\n\nIf count doesn't match the number of events, you either:\n\n- Wait forever (count too high)\n- Release too early (count too low)\n\n\n```java\n// BUG: 5 threads but count is 3\nCountDownLatch latch = new CountDownLatch(3);\n\nfor (int i = 0; i < 5; i++) {\n new Thread(() -> {\n doWork();\n latch.countDown(); // 4th and 5th countDown do nothing\n }).start();\n}\n\nlatch.await(); // Releases after 3rd thread, 2 still working!\n```\n\n\n### Pitfall 3: Trying to Reset\n\nCountDownLatch is single-use. You can't reset it:\n\n\n```java\nCountDownLatch latch = new CountDownLatch(3);\n\n// ... wait for count to reach 0 ...\n\n// This doesn't work - there's no reset method!\n// latch.reset(); // Doesn't exist\n\n// Must create a new latch\nCountDownLatch newLatch = new CountDownLatch(3);\n```\n\n\nIf you need reusability, use CyclicBarrier or Phaser.\n\n### Pitfall 4: Not Using Timeout\n\nWaiting forever is usually a bug in production:\n\n\n```java\n// DANGEROUS: Waits forever if something goes wrong\nlatch.await();\n\n// BETTER: Use timeout\nif (!latch.await(30, TimeUnit.SECONDS)) {\n throw new TimeoutException(\"Initialization took too long\");\n}\n```\n\n\n### Pitfall 5: Counting Down Too Many Times\n\nExtra `countDown()` calls are harmless but indicate a bug:\n\n\n```java\nCountDownLatch latch = new CountDownLatch(2);\n\nlatch.countDown(); // count = 1\nlatch.countDown(); // count = 0, waiters released\nlatch.countDown(); // No effect, but why is this happening?\n```\n\n\nIf you're calling `countDown()` more times than expected, your logic is wrong.\n\n### Pitfall 6: Race Between countDown and await\n\n\n```java\nCountDownLatch latch = new CountDownLatch(1);\n\n// Thread 1\nnew Thread(() -> {\n latch.countDown(); // Might run first\n}).start();\n\n// Thread 2 (main)\nlatch.await(); // Might already be 0\n```\n\n\nThis is actually fine. If `countDown()` runs first, `await()` returns immediately. The latch handles this correctly.\n\n---\n\n## 8. Advanced Patterns\n\n### Pattern 1: Deadline-Based Initialization\n\nStart accepting requests at a deadline, even if some services aren't ready:\n\n\n```java\npublic class DeadlineInitialization {\n public void initialize(List services, Duration maxWait) {\n CountDownLatch latch = new CountDownLatch(services.size());\n List failed = Collections.synchronizedList(new ArrayList<>());\n\n for (Service service : services) {\n new Thread(() -> {\n try {\n service.init();\n } catch (Exception e) {\n failed.add(service);\n } finally {\n latch.countDown();\n }\n }).start();\n }\n\n boolean allReady = latch.await(maxWait.toMillis(), TimeUnit.MILLISECONDS);\n\n if (!allReady) {\n log.warn(\"Starting with {} services still initializing\", latch.getCount());\n }\n if (!failed.isEmpty()) {\n log.error(\"Failed services: {}\", failed);\n }\n\n startServer(); // Start regardless\n }\n}\n```\n\n\n### Pattern 2: Progress Tracking\n\nMonitor progress while waiting:\n\n\n```java\npublic class ProgressTracker {\n public void processWithProgress(List tasks) {\n int total = tasks.size();\n CountDownLatch latch = new CountDownLatch(total);\n\n for (Task task : tasks) {\n executor.submit(() -> {\n try {\n process(task);\n } finally {\n latch.countDown();\n }\n });\n }\n\n // Monitor progress\n while (latch.getCount() > 0) {\n long remaining = latch.getCount();\n int completed = total - (int) remaining;\n System.out.printf(\"Progress: %d/%d (%.1f%%)%n\",\n completed, total, (completed * 100.0 / total));\n Thread.sleep(1000);\n }\n\n System.out.println(\"All tasks complete!\");\n }\n}\n```\n\n\n### Pattern 3: Cascading Latches\n\nDependencies between initialization phases:\n\n\n```mermaid\nflowchart TD\n subgraph Phase1[\"Phase 1\"]\n DB[Database]:::primary\n Config[Config]:::primary\n end\n\n L1[Latch 1
count: 2]:::orange\n\n subgraph Phase2[\"Phase 2 (needs Phase 1)\"]\n Cache[Cache]:::secondary\n Auth[Auth Service]:::secondary\n end\n\n L2[Latch 2
count: 2]:::orange\n\n Server[Start Server]:::green\n\n DB --> L1\n Config --> L1\n L1 --> Cache\n L1 --> Auth\n Cache --> L2\n Auth --> L2\n L2 --> Server\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef secondary fill:#38d9a9,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\n\n```java\nCountDownLatch phase1 = new CountDownLatch(2);\nCountDownLatch phase2 = new CountDownLatch(2);\n\n// Phase 1: No dependencies\nstartAsync(() -> { initDatabase(); phase1.countDown(); });\nstartAsync(() -> { loadConfig(); phase1.countDown(); });\n\n// Phase 2: Depends on Phase 1\nstartAsync(() -> {\n phase1.await(); // Wait for phase 1\n warmCache();\n phase2.countDown();\n});\nstartAsync(() -> {\n phase1.await();\n initAuth();\n phase2.countDown();\n});\n\n// Final: Depends on Phase 2\nphase2.await();\nstartServer();\n```\n\n\n---\n\n## 9. Implementation in Different Languages\n\n### Java\n\n\n```java\nimport java.util.concurrent.CountDownLatch;\nimport java.util.concurrent.TimeUnit;\n\nCountDownLatch latch = new CountDownLatch(3);\n\nlatch.countDown();\nlatch.await();\nlatch.await(10, TimeUnit.SECONDS);\nlong remaining = latch.getCount();\n```\n\n\n### Python\n\n\n```python\nimport threading\n\n# Python doesn't have built-in CountDownLatch\n# Use threading.Event for simple cases or implement:\nclass CountDownLatch:\n def __init__(self, count):\n self.count = count\n self.lock = threading.Condition()\n\n def count_down(self):\n with self.lock:\n self.count -= 1\n if self.count <= 0:\n self.lock.notify_all()\n\n def await(self, timeout=None):\n with self.lock:\n while self.count > 0:\n if not self.lock.wait(timeout):\n return False\n return True\n```\n\n\n### Go\n\n\n```go\n// Go uses WaitGroup, which is similar\nimport \"sync\"\n\nvar wg sync.WaitGroup\nwg.Add(3) // Set count\n\n// In workers\nwg.Done() // Like countDown()\n\n// In main\nwg.Wait() // Like await()\n```\n\n\n### C#\n\n\n```csharp\nusing System.Threading;\n\n// CountdownEvent is C#'s equivalent\nCountdownEvent latch = new CountdownEvent(3);\n\nlatch.Signal(); // Like countDown()\nlatch.Wait(); // Like await()\nlatch.Wait(TimeSpan.FromSeconds(10)); // With timeout\n```\n\n\n---\n\n## 10. Interview Applications\n\n### When to Mention CountDownLatch\n\n\n| ##### Problem | ##### Signal |\n| --- | --- |\n| \"How to wait for multiple async operations?\" | CountDownLatch |\n| \"How to ensure all services initialize?\" | CountDownLatch for startup sync |\n| \"How to coordinate test threads?\" | CountDownLatch + starting gun |\n| \"How to implement graceful shutdown?\" | CountDownLatch to wait for workers |\n| \"Difference from CyclicBarrier?\" | One-time vs reusable |\n\n\n### Interview Discussion Points\n\n1. **Problem Recognition:** \"I need to wait for N events from different sources. CountDownLatch is perfect for this, threads calling countDown don't block.\"\n2. **One-Time Nature:** \"CountDownLatch is single-use. Once count hits zero, it stays zero. For repeated sync, I'd use CyclicBarrier.\"\n3. **Non-Blocking Signal:** \"countDown() doesn't block. It's a fire-and-forget signal. This is different from CyclicBarrier where await() both signals and waits.\"\n4. **Timeout:** \"In production, I'd always use await with timeout. Waiting forever is dangerous.\"\n5. **Error Handling:** \"I'd wrap worker logic in try-finally to ensure countDown is always called, even if an exception occurs.\"\n\n### Example Interview Dialog\n\n**Interviewer:** \"Design a system that initializes multiple services in parallel and waits for all to be ready.\"\n\n**You:** \"I'd use a CountDownLatch initialized with the service count. Each service initialization runs in a separate thread. When a service finishes initializing, it calls countDown(). The main thread calls await() to block until all services are ready.\n\nI'd wrap each initialization in try-finally to ensure countDown is called even if initialization fails. I'd also use await with a timeout to avoid hanging if a service hangs.\n\nThe key benefit of CountDownLatch here is that the signaling threads (services) are different from the waiting thread (main). The services don't need to wait for each other, they just signal completion.\"\n\n---\n\n## 11. Summary\n\nA **CountDownLatch** is a synchronization primitive that allows threads to wait until a count reaches zero.\n\n\n```mermaid\nflowchart TD\n subgraph Signal[\"Signaling Threads\"]\n W1[Thread 1]:::primary\n W2[Thread 2]:::primary\n W3[Thread 3]:::primary\n end\n\n L[CountDownLatch
count: 3 → 0]:::orange\n\n W1 -->|countDown| L\n W2 -->|countDown| L\n W3 -->|countDown| L\n\n L -->|await returns| M[Waiting Thread]:::green\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\n### Key Properties\n\n\n| ##### Property | ##### Description |\n| --- | --- |\n| **One-time use** | Cannot be reset after reaching zero |\n| **Non-blocking signal** | countDown() returns immediately |\n| **Blocking wait** | await() blocks until count = 0 |\n| **Multiple waiters** | Any number of threads can await |\n\n\n### Core Operations\n\n\n| ##### Operation | ##### Behavior |\n| --- | --- |\n| **countDown()** | Decrement count, wake waiters if zero |\n| **await()** | Block until count reaches zero |\n| **await(timeout)** | Block with timeout |\n| **getCount()** | Get current count (for monitoring) |\n\n\n### Common Use Cases\n\n\n| ##### Use Case | ##### Pattern |\n| --- | --- |\n| Service initialization | Wait for N services |\n| Starting gun | Latch with count=1 |\n| Test coordination | Ready + Start + Done latches |\n| Batch completion | Wait for N tasks |\n| Graceful shutdown | Wait for N workers to stop |\n\n\n### When to Use\n\n- Waiting for events from different sources\n- One-time synchronization\n- Signaling threads don't need to wait\n- Fire-and-forget completion signals\n\n### When NOT to Use\n\n- Need to reuse (use CyclicBarrier)\n- Same threads signal and wait (use CyclicBarrier)\n- Dynamic participant count (use Phaser)\n- Need to pass data between threads (use queues)\n\nCountDownLatch is a simple but powerful primitive. It cleanly separates the threads that signal events from the threads that wait for them, making it ideal for initialization, coordination, and completion tracking.\n\n---\n\n## References\n\n- [Java CountDownLatch Documentation](undefined) - Official Java API reference\n- [Java Concurrency in Practice by Brian Goetz](undefined) - Comprehensive coverage of Java concurrency patterns\n- [C# CountdownEvent Documentation](undefined) - .NET equivalent\n- [Go sync.WaitGroup](undefined) - Go's similar primitive\n- [The Art of Multiprocessor Programming](undefined) - Academic treatment of synchronization primitives\n\n---\n\nThank you for reading!\n\nIf you found it valuable, hit a like and consider subscribing for more such content every week.\n\nIf you have any questions or suggestions, leave a comment.\n\nThis post is public so feel free to share it.\n\n[Share](undefined)\n\n---\n\n**P.S.** If you're enjoying this newsletter and want to get even more value, consider becoming a **[paid subscriber](https://blog.algomaster.io/subscribe)**.\n\nAs a paid subscriber, you'll unlock all **premium articles** and gain full access to all **[premium courses](https://algomaster.io/newsletter/paid/resources)** on **[algomaster.io](https://algomaster.io)**.\n\n[Unlock Full Access](undefined)\n\n**There are [group discounts](https://blog.algomaster.io/subscribe?group=true), [gift options](https://blog.algomaster.io/subscribe?gift=true), and [referral bonuses](https://blog.algomaster.io/leaderboard) available.**\n\n---\n\nCheckout my **[Youtube channel](https://www.youtube.com/@ashishps_1/videos)** for more in-depth content.\n\nFollow me on **[LinkedIn](https://www.linkedin.com/in/ashishps1/)** and **[X](https://twitter.com/ashishps_1)** to stay updated.\n\nCheckout my **[GitHub repositories](https://github.com/ashishps1)** for free interview preparation resources.\n\nI hope you have a lovely day!\n\nSee you soon, Ashish","pageType":"lld-interviews"}

CountdownLatch Pattern

Ashish Pratap Singh

Get Premium