CompletableFuture and Asynchrony
28 interview questions and answers in the CompletableFuture and Asynchrony section.
Questions in this section
- What is CompletableFuture and how does it differ from Future
- What are the main advantages of CompletableFuture over Future
- How to create a CompletableFuture that is already completed with result
- What is the difference between thenApply() and thenCompose()
- What do thenAccept() and thenRun() methods do
- How to handle exceptions in CompletableFuture chain
- What is the difference between handle(), exceptionally() and whenComplete()
- How to combine results of multiple CompletableFutures
- What does allOf() method do and when to use it
- What does anyOf() method do and when is it useful
- What is the difference between thenApply() and thenApplyAsync()
- What thread pool is used by default for async methods?
- How to specify your own Executor for CompletableFuture
- What is blocking code and how to distinguish it from non-blocking
- Why is it important to avoid blocking operations in CompletableFuture
- How to properly execute multiple parallel requests to microservices
- What does supplyAsync() method do and when to use it
- How to cancel CompletableFuture execution
- What happens if an exception occurs in CompletableFuture chain
- Can you reuse a single CompletableFuture in multiple chains
- How to implement timeout for CompletableFuture
- What does orTimeout() method do in Java 9+
- What is the difference between thenCombine() and thenCompose()
- How to test code with CompletableFuture
- When is it better to use CompletableFuture vs reactive programming
- What does join() method do and how does it differ from get()
- Can you manually complete a CompletableFuture with a result
- How to Implement Retry Logic with CompletableFuture
Study navigator
28 interview preparation questions for Middle/Senior Java Developer.
📋 All questions
🗺️ Topic dependency map
┌──────────────────────────────────────────┐
│ BASICS (1-5) │
│ 1. CompletableFuture vs Future │
│ 2. Advantages │
│ 3. completedFuture │
│ 4. thenApply vs thenCompose │
│ 5. thenAccept vs thenRun │
└──────────────────┬───────────────────────┘
│
┌──────────────────────────┼──────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌────────────────────┐
│ EXCEPTIONS │ │ COMBINING │ │ EXECUTORS │
│ (6-7, 19) │ │ (8-11, 23) │ │ (12-13, 17) │
│ 6. Handling │ │ 8. Combining │ │ 12. Common Pool │
│ 7. handle/ │ │ 9. allOf │ │ 13. Custom Exec. │
│ exceptionally│ │ 10. anyOf │ │ 17. supplyAsync │
│ 19. Exception │ │ 11. *Async │ │ │
│ in chain │ │ 23. thenCombine│ │ │
└───────┬───────┘ └───────┬───────┘ └────────┬───────────┘
│ │ │
└────────────────────────┼────────────────────────┘
▼
┌──────────────────────────────────────────┐
│ BLOCKING AND TIMEOUT (14-16, 20-22) │
│ 14. Blocking vs Non-blocking │
│ 15. Why avoid blocking │
│ 16. Parallel requests │
│ 20. Timeout │
│ 21. orTimeout (Java 9+) │
└──────────────────────────────────────────┘
│
┌────────────────────────┼────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌────────────────────┐
│ ADVANCED │ │ TESTING │ │ PATTERNS │
│ (18, 25-28) │ │ (24) │ │ (27) │
│ 18. Cancel │ │ 24. Testing │ │ 27. Retry │
│ 25. join vs get│ │ │ │ │
│ 26. obtrude │ │ │ │ │
│ 25. CF vs │ │ │ │ │
│ Reactive │ │ │ │ │
└───────────────┘ └───────────────┘ └────────────────────┘
🎯 Recommended study order
🟢 Junior Level (weeks 1-2)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | Basics | Q1, Q2, Q3 | How it differs from Future, completedFuture |
| 2 | Chains | Q4, Q5 | thenApply, thenCompose, thenAccept, thenRun |
| 3 | Exceptions | Q6, Q7 | exceptionally, handle, whenComplete |
| 4 | join vs get | Q25 | How they differ, why join is preferable |
🟡 Middle Level (weeks 3-4)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | Combining | Q8, Q9, Q10, Q23 | allOf, anyOf, thenCombine, thenCompose |
| 2 | Async methods | Q11, Q17 | thenApply vs thenApplyAsync, supplyAsync |
| 3 | Blocking | Q14, Q15 | What is blocking, why dangerous in commonPool |
| 4 | Timeout | Q20, Q21 | Manual timeout, orTimeout (Java 9+) |
| 5 | Testing | Q24 | Awaitility, Testcontainers, Virtual Threads |
🔴 Senior Level (weeks 5-6)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | Executors | Q12, Q13 | CommonPool internals, custom executors, ManagedBlocker |
| 2 | Parallel requests | Q16 | Semaphore + dedicated executor, error handling |
| 3 | Cancel & obtrude | Q18, Q26 | cancel() mechanics, obtrudeValue dangers |
| 4 | Reuse CF | Q19 | Fan-out, memory leak via reference chains |
| 5 | CF vs Reactive | Q25 | When to use each, Virtual Threads impact |
| 6 | Retry patterns | Q28 | exceptionallyCompose, exponential backoff + jitter |
🔗 Key topic connections
Topic: Basics
Q1 (CF vs Future) → Q2 (Advantages) → Q3 (completedFuture)
Topic: Chains
Q4 (thenApply vs thenCompose) → Q5 (thenAccept vs thenRun) → Q23 (thenCombine vs thenCompose)
Key connections:
- Q4 ↔ Q23: thenCompose = sequential, thenCombine = parallel
- Q5 ↔ Q4: thenAccept = Consumer (no result), thenRun = Runnable (no input)
Topic: Exceptions
Q6 (Handling) → Q7 (handle/exceptionally/whenComplete) → Q19 (Exception in chain)
Topic: Combining
Q8 (Combining) → Q9 (allOf) → Q10 (anyOf)
Topic: Executors and Blocking
Q12 (Common Pool) → Q13 (Custom Executor) → Q14 (Blocking) → Q15 (Why avoid)
↓
Q17 (supplyAsync) → Q16 (Parallel requests)
Key connections:
- Q12 ↔ Q15: Blocking in commonPool → thread pool starvation
- Q13 ↔ Q16: Parallel requests → dedicated executor, NOT commonPool
- Q14 ↔ Q15: Blocking vs non-blocking → why blocking is dangerous
Topic: Timeout and Cancel
Q20 (Timeout) → Q21 (orTimeout)
Q18 (Cancel) → Q26 (obtrudeValue)
🎯 Cheat sheet: what to know for each level
🟢 Junior
- CompletableFuture = async result + callback chains
- thenApply = transformation, thenAccept = side effect, thenRun = action without data
- exceptionally = fallback on error, handle = handles both success and error
- join() = blocking without checked exceptions, get() = blocking with checked exceptions
🟡 Middle
- supplyAsync by default → ForkJoinPool.commonPool()
- Blocking in commonPool → thread pool starvation for all tasks
- allOf = wait for ALL, anyOf = wait for FIRST
- orTimeout (Java 9+) = built-in timeout, in Java 8 — manually via ScheduledExecutor
- exceptionallyCompose (Java 12+) = non-blocking retry
🔴 Senior
- commonPool size = availableProcessors - 1, changeable via System.setProperty
- ManagedBlocker notifies ForkJoinPool about blocking operation
- obtrudeValue violates “single completion” contract → race conditions
- CF vs Reactive: CF = single result, Reactive = streams + backpressure
- Virtual Threads (Java 21+) simplify blocking code → CF less critical
- Retry: exponential backoff + jitter prevents thundering herd
📝 Format of each file
Each file contains:
- 🟢 Junior Level — basic understanding, simple analogies, examples
- 🟡 Middle Level — internals, typical mistakes, practical examples
- 🔴 Senior Level — deep dive, edge cases, production experience, monitoring
- 🎯 Interview cheat sheet — key points, frequent questions, red flags, related topics