What is Asynchronous Patterns?

Learn Futures, Promises, and async/await patterns for non-blocking concurrent programming. Master CompletableFuture, asyncio, and event loops.

A Future represents a value that will be available at some point in the future, allowing asynchronous computation.

What is the difference between blocking and non-blocking I/O?

Blocking I/O waits for the operation to complete, while non-blocking I/O returns immediately and notifies when ready.

What's the difference between thenApply and thenCompose in CompletableFuture?

thenApply transforms the result synchronously, while thenCompose chains another CompletableFuture asynchronously.

What is an event loop?

An event loop manages and executes asynchronous tasks, handling I/O events and scheduling callbacks efficiently.

Asynchronous Patterns

Q: When would you use async/await vs threads in Python?

Use async/await for I/O-bound concurrent operations with many connections. Use threads for CPU-bound tasks or simpler I/O scenarios.

Modern non-blocking concurrency with Futures and async/await.

By Vishnu Darshan Sanku · Updated September 25, 2026

Introduction: Futures and Promises

Futures and Promises represent values that don’t exist yet, enabling asynchronous computation without blocking threads.

Visual: Future Concept

Future lifecycle: submit returns a pending Future immediately, the task runs in the background, and get() returns the completed result

Blocking vs Non-Blocking I/O

Understanding the difference is crucial!

Visual: Blocking vs Non-Blocking

Blocking I/O leaves the thread waiting for the result, while non-blocking I/O lets it continue working and get notified when ready

Java: CompletableFuture

CompletableFuture is Java’s modern way to handle asynchronous operations.

1
import java.util.concurrent.CompletableFuture;
2
import java.util.concurrent.ExecutionException;
3

4
public class CompletableFutureBasics {
5
    public static void main(String[] args) throws ExecutionException, InterruptedException {
6
        // Create with supplyAsync (returns value)
7
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
8
            try {
9
                Thread.sleep(1000);
10
            } catch (InterruptedException e) {
11
                Thread.currentThread().interrupt();
12
            }
13
            return "Hello";
14
        });
15

16
        // Create with runAsync (no return value)
17
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
18
            System.out.println("Running async task");
19
        });
20

21
        // Get result (blocks until ready)
22
        String result = future1.get();
23
        System.out.println("Result: " + result);
24
    }
25
}

1
package main
2

3
import (
4
  "fmt"
5
  "time"
6
)
7

8
func main() {
9
  // Create a channel-based "future" (returns value)
10
  future1 := make(chan string, 1)
11
  go func() {
12
    time.Sleep(1 * time.Second)
13
    future1 <- "Hello"
14
  }()
15

16
  // Fire-and-forget goroutine (no return value)
17
  done := make(chan struct{}, 1)
18
  go func() {
19
    fmt.Println("Running async task")
20
    done <- struct{}{}
21
  }()
22

23
  // Get result (blocks until ready)
24
  result := <-future1
25
  fmt.Println("Result:", result)
26

27
  <-done
28
}

Chaining Operations

thenApply vs thenCompose

thenApply: Transforms result synchronously (returns value)
thenCompose: Chains another CompletableFuture (returns Future)

Visual: thenApply vs thenCompose

CompletableFuture thenApply synchronously transforms a String to its length, while thenCompose chains another async fetchData call

Example: Chaining Operations

Java
Go

1
import java.util.concurrent.CompletableFuture;
2

3
public class CompletableFutureChaining {
4
    public static void main(String[] args) {
5
        // Chain operations
6
        CompletableFuture<String> future = CompletableFuture
7
            .supplyAsync(() -> "Hello")
8
            .thenApply(s -> s + " World")  // Synchronous transformation
9
            .thenApply(String::toUpperCase);  // Another transformation
10

11
        future.thenAccept(System.out::println);  // Consume result
12

13
        // thenCompose for async chaining
14
        CompletableFuture<String> future2 = CompletableFuture
15
            .supplyAsync(() -> "user123")
16
            .thenCompose(userId -> fetchUserData(userId));  // Returns Future
17

18
        // Exception handling
19
        CompletableFuture<String> future3 = CompletableFuture
20
            .supplyAsync(() -> {
21
                if (Math.random() > 0.5) {
22
                    throw new RuntimeException("Error!");
23
                }
24
                return "Success";
25
            })
26
            .exceptionally(ex -> "Handled: " + ex.getMessage())  // Handle exception
27
            .thenApply(s -> "Result: " + s);
28
    }
29

30
    static CompletableFuture<String> fetchUserData(String userId) {
31
        return CompletableFuture.supplyAsync(() -> {
32
            // Simulate async fetch
33
            return "Data for " + userId;
34
        });
35
    }
36
}

1
package main
2

3
import (
4
  "errors"
5
  "fmt"
6
  "math/rand"
7
)
8

9
// pipeline step: transform a string to uppercase
10
func toUpper(s string) string {
11
  result := make([]byte, len(s))
12
  for i, c := range s {
13
    if c >= 'a' && c <= 'z' {
14
      result[i] = byte(c - 32)
15
    } else {
16
      result[i] = byte(c)
17
    }
18
  }
19
  return string(result)
20
}
21

22
// fetchUserData simulates an async fetch — returns a channel
23
func fetchUserData(userID string) <-chan string {
24
  ch := make(chan string, 1)
25
  go func() {
26
    ch <- "Data for " + userID
27
  }()
28
  return ch
29
}
30

31
func main() {
32
  // Chain: "Hello" -> "Hello World" -> "HELLO WORLD"
33
  step1 := make(chan string, 1)
34
  go func() { step1 <- "Hello" }()
35

36
  step2 := make(chan string, 1)
37
  go func() {
38
    s := <-step1
39
    step2 <- s + " World"
40
  }()
41

42
  step3 := make(chan string, 1)
43
  go func() {
44
    s := <-step2
45
    step3 <- toUpper(s)
46
  }()
47
  fmt.Println(<-step3) // "HELLO WORLD"
48

49
  // thenCompose equivalent: chain another async operation
50
  userDataCh := fetchUserData("user123")
51
  fmt.Println(<-userDataCh)
52

53
  // Exception handling equivalent
54
  resultCh := make(chan string, 1)
55
  go func() {
56
    if rand.Float64() > 0.5 {
57
      resultCh <- "Handled: Error!"
58
    } else {
59
      resultCh <- "Result: Success"
60
    }
61
  }()
62
  fmt.Println(<-resultCh)
63
}

Combining Futures

allOf: Wait for all futures to complete
anyOf: Wait for any future to complete

Java
Go

1
import java.util.concurrent.CompletableFuture;
2
import java.util.Arrays;
3

4
public class CombiningFutures {
5
    public static void main(String[] args) {
6
        // Create multiple futures
7
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result 1");
8
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Result 2");
9
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "Result 3");
10

11
        // Wait for all
12
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);
13
        allFutures.thenRun(() -> {
14
            System.out.println("All completed!");
15
        });
16

17
        // Wait for any
18
        CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2, future3);
19
        anyFuture.thenAccept(result -> {
20
            System.out.println("First result: " + result);
21
        });
22

23
        // Combine two futures
24
        CompletableFuture<String> combined = future1.thenCombine(future2,
25
            (r1, r2) -> r1 + " + " + r2);
26
    }
27
}

1
package main
2

3
import (
4
  "fmt"
5
  "sync"
6
)
7

8
func asyncTask(result string) <-chan string {
9
  ch := make(chan string, 1)
10
  go func() { ch <- result }()
11
  return ch
12
}
13

14
func main() {
15
  ch1 := asyncTask("Result 1")
16
  ch2 := asyncTask("Result 2")
17
  ch3 := asyncTask("Result 3")
18

19
  // allOf equivalent: wait for all
20
  var wg sync.WaitGroup
21
  results := make([]string, 3)
22
  channels := []<-chan string{ch1, ch2, ch3}
23
  for i, ch := range channels {
24
    wg.Add(1)
25
    go func(idx int, c <-chan string) {
26
      defer wg.Done()
27
      results[idx] = <-c
28
    }(i, ch)
29
  }
30
  wg.Wait()
31
  fmt.Println("All completed:", results)
32

33
  // anyOf equivalent: wait for first
34
  ch4 := asyncTask("Fast 1")
35
  ch5 := asyncTask("Fast 2")
36
  ch6 := asyncTask("Fast 3")
37
  select {
38
  case r := <-ch4:
39
    fmt.Println("First result:", r)
40
  case r := <-ch5:
41
    fmt.Println("First result:", r)
42
  case r := <-ch6:
43
    fmt.Println("First result:", r)
44
  }
45

46
  // Combine two futures
47
  a := asyncTask("Left")
48
  b := asyncTask("Right")
49
  combined := <-a + " + " + <-b
50
  fmt.Println(combined)
51
}

Python: asyncio

Python’s asyncio provides async/await syntax for asynchronous programming.

Event Loop

The event loop manages and executes asynchronous tasks.

Visual: Event Loop

Python asyncio event loop managing a task queue, I/O-waiting and ready tasks: run ready tasks, suspend on I/O, resume when I/O is ready

Example: Basic asyncio

Python
Go

1
import asyncio
2

3
async def fetch_data(url):
4
    """Async function (coroutine)"""
5
    await asyncio.sleep(1)  # Simulate I/O
6
    return f"Data from {url}"
7

8
async def main():
9
    # Run coroutines concurrently
10
    results = await asyncio.gather(
11
        fetch_data("url1"),
12
        fetch_data("url2"),
13
        fetch_data("url3")
14
    )
15
    print(results)
16

17
# Run event loop
18
asyncio.run(main())

1
package main
2

3
import (
4
  "fmt"
5
  "sync"
6
)
7

8
func fetchData(url string) string {
9
  // Simulate I/O
10
  return "Data from " + url
11
}
12

13
func main() {
14
  urls := []string{"url1", "url2", "url3"}
15
  results := make([]string, len(urls))
16
  var wg sync.WaitGroup
17

18
  // Run fetches concurrently (Go's gather equivalent)
19
  for i, url := range urls {
20
    wg.Add(1)
21
    go func(idx int, u string) {
22
      defer wg.Done()
23
      results[idx] = fetchData(u)
24
    }(i, url)
25
  }
26

27
  wg.Wait()
28
  fmt.Println(results)
29
}

concurrent.futures.Future vs asyncio.Future

Python
Go

1
from concurrent.futures import ThreadPoolExecutor, Future as ThreadFuture
2
import asyncio
3

4
# ThreadPoolExecutor Future
5
def sync_task():
6
    return "Result"
7

8
with ThreadPoolExecutor() as executor:
9
    thread_future = executor.submit(sync_task)
10
    result = thread_future.result()  # Blocks
11

12
# asyncio Future
13
async def async_task():
14
    await asyncio.sleep(1)
15
    return "Result"
16

17
async def main():
18
    asyncio_future = asyncio.create_task(async_task())
19
    result = await asyncio_future  # Non-blocking
20
    print(result)
21

22
asyncio.run(main())

1
package main
2

3
import (
4
  "fmt"
5
  "sync"
6
)
7

8
// Synchronous task submitted to a "thread pool" via goroutine
9
func syncTask() string {
10
  return "Result"
11
}
12

13
// Async task returning a channel (non-blocking future)
14
func asyncTask() <-chan string {
15
  ch := make(chan string, 1)
16
  go func() {
17
    ch <- "Result"
18
  }()
19
  return ch
20
}
21

22
func main() {
23
  // Goroutine-pool style (sync task)
24
  var wg sync.WaitGroup
25
  var syncResult string
26
  wg.Add(1)
27
  go func() {
28
    defer wg.Done()
29
    syncResult = syncTask() // blocks goroutine, not main
30
  }()
31
  wg.Wait()
32
  fmt.Println(syncResult)
33

34
  // Channel future (non-blocking)
35
  future := asyncTask()
36
  result := <-future // await equivalent
37
  fmt.Println(result)
38
}

Cross-Language Comparison

Feature	Java	Python
Future Creation	`CompletableFuture.supplyAsync()`	`asyncio.create_task()` or `executor.submit()`
Chaining	`thenApply()`, `thenCompose()`	`await` in coroutines
Combining	`allOf()`, `anyOf()`	`asyncio.gather()`, `asyncio.wait()`
Exception Handling	`exceptionally()`, `handle()`	`try/except` in coroutines
Event Loop	Implicit (ForkJoinPool)	Explicit (`asyncio.run()`)

Real-World Example: Async API Client

1
import java.util.concurrent.CompletableFuture;
2
import java.util.List;
3
import java.util.stream.Collectors;
4

5
public class AsyncAPIClient {
6
    public CompletableFuture<String> fetchUser(String userId) {
7
        return CompletableFuture.supplyAsync(() -> {
8
            // Simulate API call
9
            try {
10
                Thread.sleep(100);
11
            } catch (InterruptedException e) {
12
                Thread.currentThread().interrupt();
13
            }
14
            return "User: " + userId;
15
        });
16
    }
17

18
    public CompletableFuture<List<String>> fetchUsers(List<String> userIds) {
19
        List<CompletableFuture<String>> futures = userIds.stream()
20
            .map(this::fetchUser)
21
            .collect(Collectors.toList());
22

23
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
24
            .thenApply(v -> futures.stream()
25
                .map(CompletableFuture::join)
26
                .collect(Collectors.toList()));
27
    }
28
}

1
import asyncio
2

3
class AsyncAPIClient:
4
    async def fetch_user(self, user_id):
5
        """Simulate async API call"""
6
        await asyncio.sleep(0.1)
7
        return f"User: {user_id}"
8

9
    async def fetch_users(self, user_ids):
10
        """Fetch multiple users concurrently"""
11
        tasks = [self.fetch_user(uid) for uid in user_ids]
12
        return await asyncio.gather(*tasks)
13

14
# Usage
15
async def main():
16
    client = AsyncAPIClient()
17
    users = await client.fetch_users(["user1", "user2", "user3"])
18
    print(users)
19

20
asyncio.run(main())

1
package main
2

3
import (
4
  "fmt"
5
  "sync"
6
  "time"
7
)
8

9
type AsyncAPIClient struct{}
10

11
func (c *AsyncAPIClient) fetchUser(userID string) <-chan string {
12
  ch := make(chan string, 1)
13
  go func() {
14
    time.Sleep(100 * time.Millisecond) // simulate API call
15
    ch <- "User: " + userID
16
  }()
17
  return ch
18
}
19

20
func (c *AsyncAPIClient) fetchUsers(userIDs []string) []string {
21
  channels := make([]<-chan string, len(userIDs))
22
  for i, id := range userIDs {
23
    channels[i] = c.fetchUser(id)
24
  }
25

26
  // Collect all results concurrently
27
  results := make([]string, len(userIDs))
28
  var wg sync.WaitGroup
29
  for i, ch := range channels {
30
    wg.Add(1)
31
    go func(idx int, c <-chan string) {
32
      defer wg.Done()
33
      results[idx] = <-c
34
    }(i, ch)
35
  }
36
  wg.Wait()
37
  return results
38
}
39

40
func main() {
41
  client := &AsyncAPIClient{}
42
  users := client.fetchUsers([]string{"user1", "user2", "user3"})
43
  fmt.Println(users)
44
}

Interview Questions

Q1: “What’s the difference between `thenApply` and `thenCompose`?”

Answer:

thenApply: Synchronous transformation, takes value, returns value
thenCompose: Asynchronous chaining, takes value, returns Future
Use thenApply: For simple transformations
Use thenCompose: When you need to chain another async operation

Q2: “When would you use async/await vs threads in Python?”