{"title":"Future/Promise Pattern","description":null,"content":"# Future/Promise Pattern Explained\n\nYou're building a price comparison service. When a user searches for a product, you need to fetch prices from Amazon, eBay, and Walmart. Each API call takes 200-500ms.\n\nThe naive approach calls each API sequentially. Total time: 600-1500ms. Users wait while your server sits idle between network calls.\n\nYou could use threads and callbacks. Spawn three threads, each calls an API and invokes a callback with the result. But now you're managing thread lifecycles, synchronizing callbacks, handling partial failures, and your code looks like spaghetti.\n\nThe **Future/Promise Pattern** solves this elegantly. A Future is a placeholder for a result that will arrive later. You start all three API calls, get three Futures immediately, and combine them. The framework handles threading, synchronization, and composition. Your code stays clean and readable.\n\nIn this article, we'll explore:\n\n- What is the Future/Promise Pattern?\n- The problem it solves\n- How it works\n- Creating and consuming Futures\n- Composing multiple Futures\n- Error handling\n- Common pitfalls\n- When to use it in LLD interviews\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 the Future/Promise Pattern?\n\nThe **Future/Promise Pattern** represents the result of an asynchronous computation. A Future is a read-only placeholder that will eventually contain a value or an error. A Promise is the writable side that completes the Future.\n\n\n```mermaid\nflowchart LR\n subgraph Producer[\"Producer Side\"]\n P[Async Task]:::primary --> PR[Promise]:::orange\n end\n\n subgraph Consumer[\"Consumer Side\"]\n F[Future]:::purple --> C[Consumer]:::primary\n end\n\n PR -->|completes| F\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef purple fill:#9775fa,stroke:#000,color:#000\n```\n\n\nThink of it like ordering food at a restaurant. You get a receipt (Future) immediately. The kitchen (async task) prepares your food and delivers it (completes the Promise). You can do other things while waiting, and when the food is ready, you're notified.\n\n### Key Concepts\n\n\n| ##### Term | ##### Description |\n| --- | --- |\n| **Future** | Read-only handle to a pending result |\n| **Promise** | Write-once handle to complete a Future |\n| **Pending** | Result not yet available |\n| **Completed** | Result available (success or failure) |\n| **Callback** | Function called when Future completes |\n\n\n### The Two Perspectives\n\n\n```mermaid\nflowchart TD\n subgraph Promise[\"Promise (Producer)\"]\n direction TB\n P1[Create]:::primary --> P2[Do work]:::orange --> P3[Complete with value
or fail with error]:::green\n end\n\n subgraph Future[\"Future (Consumer)\"]\n direction TB\n F1[Receive Future]:::primary --> F2[Attach callbacks
or block]:::orange --> F3[Process result]:::green\n end\n\n P3 -.->|delivers result| F3\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---\n\n## 2. The Problem: Blocking and Callback Hell\n\nWithout Futures, handling async operations is painful.\n\n### Problem 1: Blocking Wastes Resources\n\n\n```mermaid\nflowchart LR\n subgraph Sequential[\"Sequential Blocking\"]\n A1[Call API 1
wait 300ms]:::primary --> A2[Call API 2
wait 400ms]:::primary --> A3[Call API 3
wait 300ms]:::primary\n end\n\n T[Total: 1000ms]:::red\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe thread blocks on each call, doing nothing while waiting for network responses.\n\n### Problem 2: Manual Threading is Complex\n\n\n```java\n// Manual thread management - error prone\nThread t1 = new Thread(() -> {\n result1 = callApi1();\n latch.countDown();\n});\nThread t2 = new Thread(() -> {\n result2 = callApi2();\n latch.countDown();\n});\nt1.start();\nt2.start();\nlatch.await(); // Coordinate manually\n// Handle exceptions? Thread pool? Timeouts?\n```\n\n\nYou manage thread creation, coordination, and error handling manually.\n\n### Problem 3: Callback Hell\n\n\n```java\n// Nested callbacks become unreadable\nfetchUser(userId, user -> {\n fetchOrders(user, orders -> {\n fetchProducts(orders, products -> {\n fetchReviews(products, reviews -> {\n // 4 levels deep, error handling nightmare\n }, error -> handleError(error));\n }, error -> handleError(error));\n }, error -> handleError(error));\n}, error -> handleError(error));\n```\n\n\nEach async step adds a nesting level. Error handling duplicates everywhere.\n\n### The Solution: Futures\n\n\n```mermaid\nflowchart LR\n subgraph Parallel[\"Parallel with Futures\"]\n A1[Call API 1]:::primary\n A2[Call API 2]:::primary\n A3[Call API 3]:::primary\n end\n\n A1 --> C[Combine Results]:::orange\n A2 --> C\n A3 --> C\n\n T[Total: ~400ms
max of all calls]:::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\nStart all calls, get Futures, combine them. The framework handles parallelism.\n\n---\n\n## 3. How Futures Work\n\nA Future has a lifecycle from creation to completion.\n\n### Future Lifecycle\n\n\n```mermaid\nstateDiagram-v2\n [*] --> Pending: Future created\n Pending --> Completed: Promise fulfilled\n Pending --> Failed: Promise rejected\n\n Completed --> [*]: Value retrieved\n Failed --> [*]: Error handled\n\n note right of Pending: Callbacks can be attached\n note right of Completed: Value is available\n note right of Failed: Error is available\n```\n\n\n### The Execution Flow\n\n\n```mermaid\nsequenceDiagram\n participant C as Caller\n participant F as Future\n participant E as Executor\n participant T as Task\n\n C->>E: submit(task)\n E->>F: create Future\n E-->>C: return Future\n E->>T: execute async\n\n Note over C: Can do other work\n\n T->>T: Process...\n T->>F: complete(result)\n\n C->>F: get() or callback\n F-->>C: result\n```\n\n\nThe caller gets the Future immediately and can:\n\n1. Block with `get()` until the result is ready\n2. Attach callbacks that execute when complete\n3. Compose with other Futures\n\n---\n\n## 4. Basic Implementation\n\n### 4.1 Creating a Future\n\n\n```java\nExecutorService executor = Executors.newFixedThreadPool(4);\n\n// Submit task, get Future immediately\nFuture future = executor.submit(() -> {\n Thread.sleep(1000); // Simulate work\n return \"Result\";\n});\n\n// Do other work while task runs...\n\n// Block until result is ready\nString result = future.get();\n```\n\n\n### 4.2 The Promise Side\n\nA Promise lets you manually complete a Future.\n\n\n```java\nCompletableFuture promise = new CompletableFuture<>();\n\n// Some async operation will complete this\nexecutor.submit(() -> {\n String result = fetchFromApi();\n promise.complete(result); // Fulfill the promise\n});\n\n// Consumer uses it as a Future\nString result = promise.get();\n```\n\n\n### 4.3 Future States\n\n\n```mermaid\nflowchart TD\n F[Future]:::primary --> Q{State?}:::orange\n\n Q -->|Pending| P[Not done
get blocks]:::secondary\n Q -->|Completed| C[Done
get returns value]:::green\n Q -->|Failed| E[Done
get throws exception]:::red\n Q -->|Cancelled| X[Done
get throws CancellationException]:::red\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 classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\n---\n\n## 5. Non-Blocking with Callbacks\n\nBlocking defeats the purpose. Use callbacks to react when the Future completes.\n\n### Attaching Callbacks\n\n\n```java\nCompletableFuture future = fetchDataAsync();\n\n// Callback when complete - no blocking\nfuture.thenAccept(result -> {\n System.out.println(\"Got: \" + result);\n});\n\n// Continue immediately, don't wait\nSystem.out.println(\"Request sent, continuing...\");\n```\n\n\n### Callback Flow\n\n\n```mermaid\nsequenceDiagram\n participant M as Main Thread\n participant F as Future\n participant CB as Callback\n\n M->>F: thenAccept(callback)\n M->>M: Continue other work\n\n Note over F: Task completes...\n\n F->>CB: Execute callback\n CB->>CB: Process result\n```\n\n\nThe main thread never blocks. When the result arrives, the callback runs.\n\n---\n\n## 6. Composing Futures\n\nThe real power of Futures is composition. Chain operations, combine results, handle errors declaratively.\n\n### 6.1 Transform Results (map/thenApply)\n\nTransform a Future's result without blocking.\n\n\n```mermaid\nflowchart LR\n F1[Future A]:::primary -->|thenApply| F2[Future B]:::orange\n\n subgraph Transform\n A[String]:::secondary -->|transform| B[Integer]:::green\n end\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\nCompletableFuture lengthFuture = fetchDataAsync()\n .thenApply(data -> data.length()); // Transform String to Integer\n```\n\n\n### 6.2 Chain Async Operations (flatMap/thenCompose)\n\nWhen one async operation depends on another's result.\n\n\n```mermaid\nflowchart LR\n F1[Fetch User]:::primary -->|thenCompose| F2[Fetch Orders]:::orange -->|thenCompose| F3[Fetch Items]:::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\n```java\nCompletableFuture> items = fetchUser(userId)\n .thenCompose(user -> fetchOrders(user.getId()))\n .thenCompose(orders -> fetchItems(orders));\n```\n\n\nNo nesting. Each step flows into the next.\n\n### 6.3 Combine Independent Futures\n\nRun operations in parallel and combine results.\n\n\n```mermaid\nflowchart TD\n subgraph Parallel[\"Parallel Execution\"]\n F1[Fetch Amazon]:::primary\n F2[Fetch eBay]:::primary\n F3[Fetch Walmart]:::primary\n end\n\n C[Combine All]:::orange\n\n F1 --> C\n F2 --> C\n F3 --> C\n\n R[Combined Result]:::green\n\n C --> R\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\n```java\nCompletableFuture amazon = fetchAmazonPrice(product);\nCompletableFuture ebay = fetchEbayPrice(product);\nCompletableFuture walmart = fetchWalmartPrice(product);\n\n// Wait for all three\nCompletableFuture all = CompletableFuture.allOf(amazon, ebay, walmart);\n\nall.thenRun(() -> {\n Price best = findBest(amazon.join(), ebay.join(), walmart.join());\n displayResult(best);\n});\n```\n\n\n### 6.4 Race: First to Complete\n\nSometimes you only need the fastest response.\n\n\n```mermaid\nflowchart TD\n subgraph Race[\"Racing Futures\"]\n F1[Server 1]:::primary\n F2[Server 2]:::primary\n F3[Server 3]:::primary\n end\n\n W[anyOf]:::orange\n\n F1 --> W\n F2 --> W\n F3 --> W\n\n R[First Result Wins]:::green\n\n W --> R\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\n```java\nCompletableFuture

Future/Promise Pattern

Ashish Pratap Singh

Get Premium