Đồng thờiConcurrency

Future / Promiseaka CompletableFuture, Async/Await, Deferred

Khởi động việc chậm ngay bây giờ, nhận về một 'phiếu hẹn' để lấy kết quả sau.Start slow work now and get an 'IOU' you can redeem for the result later.

Độ khóDifficulty: VừaMedium
Mức phổ biếnUsage: Mức phổ biếnUsage 5/5
Thời gian đọcReading time: ~9 phút đọc~9 min read

Thảo luậnDiscussion

Ví dụ đời thườngReal-life analogy

Bạn gọi món ở food court và nhận một chiếc thẻ rung. Bạn không đứng chờ trước quầy mà đi lấy nước, tìm bàn. Khi thẻ rung là món đã xong — hoặc quầy báo hết món. Thẻ rung chính là Future: một lời hứa về kết quả trong tương lai.You order at a food court and get a buzzer. Instead of waiting at the counter you grab a drink and find a table. When it buzzes, your food is ready — or the stall tells you it's sold out. The buzzer is the Future: a promise of a result to come.

Vấn đề và giải phápProblem and solution

Không có patternWithout the pattern

Trang chi tiết sản phẩm cần gọi 3 service: thông tin sản phẩm (200ms), giá + khuyến mãi (250ms), đánh giá (150ms). Gọi tuần tự thì mất 600ms — khách thấy trang chậm. Ba lời gọi này hoàn toàn độc lập, vậy mà mỗi cái lại phải chờ cái trước.A product detail page calls 3 services: product info (200ms), price + promotions (250ms), reviews (150ms). Calling them sequentially takes 600ms — customers feel the lag. The three calls are fully independent, yet each one waits for the previous.

Với Future / PromiseWith Future / Promise

Khởi động cả ba lời gọi cùng lúc, mỗi lời gọi trả ngay về một Future đại diện cho kết quả sẽ có. Sau đó kết hợp (thenCombine/allOf) hoặc chờ (join/Await) để ghép trang. Tổng thời gian ≈ lời gọi chậm nhất (~250ms), và mỗi Future mang theo cả lỗi để xử lý riêng.Start all three calls at once; each immediately returns a Future representing the result to come. Then combine (thenCombine/allOf) or wait (join/Await) to assemble the page. Total time ≈ the slowest call (~250ms), and each Future carries its own error to handle separately.

Thành phần tham giaParticipants

Caller: Khởi động việc bất đồng bộ và giữ các Future.Starts async work and holds the Futures.
Future: Phía ĐỌC: tay cầm chỉ-đọc tới kết quả hoặc lỗi sẽ có.The READ side: a read-only handle to a result or error to come.
Promise / Completer: Phía GHI: nơi task chạy nền đặt giá trị hoặc lỗi (complete / gửi vào channel).The WRITE side: where the background task sets the value or error (complete / send on a channel).
Executor: Nơi task thực sự chạy (thread pool, virtual thread, goroutine).Where the task actually runs (thread pool, virtual thread, goroutine).

Sơ đồ và luồng thực thiDiagram and execution flow

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

1Load("SKU-42") khởi động 3 task cùng lúc và nhận ngay 3 Future — chưa có dữ liệu nào, nhưng cũng chưa phải chờ gì.Load("SKU-42") starts 3 tasks at once and instantly gets 3 Futures — no data yet, but no waiting either.

← →

console

1t=0ms start catalog, pricing, reviews

implementsimplementsextendsextendsgọi / dùngcalls / usestạo racreatesgửi qua channelsends via channel1thứ tự chạy (bấm để nhảy bước)execution order (click to jump)

Code: Java Spring Boot ⇄ GoCode: Java Spring Boot ⇄ Go

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

JavaSpring Boot 3 · Java 21Spring Boot 3 · Java 21

package com.shop.product;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Configuration
class AsyncConfig {
    // Remote calls mostly wait on I/O -> one virtual thread per task
    @Bean(destroyMethod = "close")1
    ExecutorService ioPool() {
        return Executors.newVirtualThreadPerTaskExecutor();2
    }
}

GoGo 1.23 · thư viện chuẩnGo 1.23 · standard library

package product

import "context"

type result[T any] struct {1
	val T
	err error
}

// Future is a read-once handle to a value computed in the background.
type Future[T any] struct {
	ch chan result[T]
}

func Async[T any](ctx context.Context, fn func(context.Context) (T, error)) *Future[T] {
	f := &Future[T]{ch: make(chan result[T], 1)} // buffer 1: the sender never blocks2
	go func() {3
		v, err := fn(ctx)
		f.ch <- result[T]{val: v, err: err}
	}()
	return f
}

// Await blocks until the value is ready or ctx is done. Call it once.
func (f *Future[T]) Await(ctx context.Context) (T, error) {
	select {
	case r := <-f.ch:4
		return r.val, r.err
	case <-ctx.Done():
		var zero T
		return zero, ctx.Err()
	}
}

Khác biệt chính giữa Java và GoKey differences between Java and Go

01Java có Future 'đóng gói sẵn' (CompletableFuture) với hàng chục combinator: thenApply, thenCombine, allOf, exceptionally, orTimeout. Go không có kiểu Future — goroutine + channel buffer 1 (hoặc errgroup) là đủ.Java has a ready-made Future (CompletableFuture) with dozens of combinators: thenApply, thenCombine, allOf, exceptionally, orTimeout. Go has no Future type — a goroutine + a buffer-1 channel (or errgroup) is enough.
02Java hay viết kiểu callback chain không chặn. Go viết code chặn bình thường trong goroutine — runtime lo việc không chặn OS thread, nên code đọc như tuần tự.Java often uses non-blocking callback chains. Go just writes blocking code inside goroutines — the runtime avoids blocking OS threads, so code reads sequentially.
03Timeout/huỷ: Java dùng orTimeout/completeOnTimeout trên từng Future (nhưng không tự ngắt task đang chạy). Go truyền context.Context xuống tận lời gọi I/O để huỷ thật sự.Timeouts/cancellation: Java uses orTimeout/completeOnTimeout per Future (which does NOT stop the running task). Go passes context.Context down to the I/O call so it is really cancelled.
04Lỗi: Java bọc trong CompletionException/ExecutionException. Go trả (T, error) từ Await hoặc g.Wait().Errors: Java wraps them in CompletionException/ExecutionException. Go returns (T, error) from Await or g.Wait().

Ứng dụng thực tếReal-world usage

Spring @Async + CompletableFutureSpring @Async + CompletableFuture
Method @Async trả về CompletableFuture<T>; controller Spring MVC/WebFlux có thể trả Future/Mono trực tiếp.An @Async method returns CompletableFuture<T>; Spring MVC/WebFlux controllers can return a Future/Mono directly.
HttpClient của Java 11+Java 11+ HttpClient
client.sendAsync(req, BodyHandlers.ofString()) trả về CompletableFuture<HttpResponse>.client.sendAsync(req, BodyHandlers.ofString()) returns a CompletableFuture<HttpResponse>.
errgroup trong GoGo errgroup
golang.org/x/sync/errgroup: chạy nhiều task, chờ tất cả, lấy lỗi đầu tiên và huỷ phần còn lại — dùng rộng rãi trong Kubernetes, Docker.golang.org/x/sync/errgroup: run several tasks, wait for all, take the first error and cancel the rest — used widely in Kubernetes, Docker.
Trang tổng hợp (BFF)Aggregation pages (BFF)
Trang sản phẩm, trang chủ app ví, màn hình chuyến xe: gọi song song nhiều microservice rồi ghép một response.Product pages, e-wallet home screens, ride screens: call several microservices in parallel, then build one response.

Khi nào dùng và khi nào khôngWhen to use it, and when not

Nên dùng khiUse it when

Có nhiều lời gọi I/O độc lập có thể chạy song song rồi ghép kết quả.You have several independent I/O calls that can run in parallel and be combined.
Muốn khởi động việc chậm sớm và làm việc khác trong lúc chờ.You want to kick off slow work early and do something else while waiting.
Cần timeout hoặc giá trị dự phòng riêng cho từng lời gọi.You need a timeout or a fallback value per call.

Không nên dùng khiAvoid it when

Các bước phụ thuộc nhau tuần tự (bước 2 cần kết quả bước 1) — Future không làm nhanh hơn, chỉ thêm phức tạp.Steps depend on each other in sequence (step 2 needs step 1) — Futures won't speed it up, only add complexity.
Dòng dữ liệu liên tục, nhiều phần tử — dùng Pipeline/Reactive stream thay vì một Future cho mỗi phần tử.A continuous stream of many items — use a Pipeline/reactive stream rather than one Future per item.

Ưu điểmPros

Giảm độ trễ: tổng thời gian ≈ lời gọi chậm nhất.Lower latency: total time ≈ the slowest call.
Tách 'bắt đầu việc' khỏi 'lấy kết quả', code ghép kết quả gọn gàng.Separates 'starting work' from 'getting results'; combining code stays tidy.
Xử lý lỗi, timeout, giá trị dự phòng cho từng nhánh riêng biệt.Per-branch error handling, timeouts and fallbacks.

Nhược điểmCons

Chuỗi callback dài khó đọc, stack trace khó lần theo.Long callback chains are hard to read; stack traces are hard to follow.
Dễ quên huỷ: timeout ở Future Java không dừng task bên dưới; Go quên buffer hoặc context → goroutine leak.Easy to forget cancellation: a Java Future timeout doesn't stop the underlying task; in Go, forgetting the buffer or context → goroutine leak.
Ghi vào biến dùng chung từ nhiều task mà không đồng bộ → data race.Writing shared variables from several tasks without synchronisation → data races.

Anti-pattern: lỗi thường gặpAnti-pattern: common mistake

Future rồi .get() ngay lập tứcCreating a Future and calling .get() right away

Gọi join()/get() ngay sau mỗi supplyAsync biến code thành tuần tự (600ms) nhưng còn tốn thêm thread và khó đọc hơn. Hãy khởi động TẤT CẢ trước, rồi mới chờ. Ngoài ra không truyền executor → chạy trên commonPool dùng chung.Calling join()/get() right after each supplyAsync makes the code sequential again (600ms) while costing extra threads and readability. Start ALL tasks first, then wait. Also, no executor → it runs on the shared commonPool.

public ProductPage load(String sku) {
    // ❌ each join() waits before the next call even starts
    Product p = CompletableFuture.supplyAsync(() -> catalog.find(sku)).join();
    Price price = CompletableFuture.supplyAsync(() -> pricing.priceFor(sku)).join();
    List<Review> rs = CompletableFuture.supplyAsync(() -> reviews.top(sku, 5)).join();
    // ❌ no executor -> blocking I/O on ForkJoinPool.commonPool
    return new ProductPage(p, price, rs);
}

Dễ nhầm vớiEasily confused with

Future / Promise vs Fan-out / Fan-in

Future đại diện cho MỘT kết quả bất đồng bộ. Fan-out/Fan-in chia một tập việc cho nhiều worker rồi gộp NHIỀU kết quả — thường được xây từ nhiều Future hoặc channel.A Future represents ONE async result. Fan-out/Fan-in spreads a set of work across many workers and merges MANY results — often built from many Futures or channels.

Bài tập áp dụngExercise

Màn hình chọn xe của app gọi xe cần lấy giá từ 3 hãng (A, B, C) song song. Hãng nào quá 500ms thì bỏ qua; trả về danh sách giá của các hãng trả lời kịp.A ride-hailing app's vehicle picker needs prices from 3 providers (A, B, C) in parallel. Skip any provider slower than 500ms; return the prices of those that answer in time.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 5Question 1 of 5

Ba lời gọi độc lập mất 200ms, 250ms, 150ms. Dùng Future đúng cách, tổng thời gian xấp xỉ bao nhiêu?Three independent calls take 200ms, 250ms and 150ms. Using Futures correctly, roughly how long does it take in total?

Phím 1–4 để chọn đáp án, Enter để kiểm tra.Press 1–4 to choose an answer, Enter to check.

Thẻ ghi nhớFlashcards

Ôn tập ngắt quãng (spaced repetition): thẻ được lặp lại sau 1 → 3 → 7 → 14 → 30 ngày để củng cố trí nhớ dài hạn.Spaced repetition: cards are repeated after 1 → 3 → 7 → 14 → 30 days to build long-term memory.

Pattern liên quanRelated patterns

Fan-out / Fan-in Worker Pool Cancellation / Context Pipeline

Thảo luậnDiscussion

Future / Promiseaka CompletableFuture, Async/Await, Deferred

Khởi động việc chậm ngay bây giờ, nhận về một 'phiếu hẹn' để lấy kết quả sau.Start slow work now and get an 'IOU' you can redeem for the result later.

VừaMedium

Mức phổ biếnUsage 5/5

~9 phút đọc~9 min read

package com.shop.product; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @Configuration class AsyncConfig { // Remote calls mostly wait on I/O -> one virtual thread per task @Bean(destroyMethod = "close")1 ExecutorService ioPool() { return Executors.newVirtualThreadPerTaskExecutor();2 } }

package product import "context" type result[T any] struct {1 val T err error } // Future is a read-once handle to a value computed in the background. type Future[T any] struct { ch chan result[T] } func Async[T any](ctx context.Context, fn func(context.Context) (T, error)) *Future[T] { f := &Future[T]{ch: make(chan result[T], 1)} // buffer 1: the sender never blocks2 go func() {3 v, err := fn(ctx) f.ch <- result[T]{val: v, err: err} }() return f } // Await blocks until the value is ready or ctx is done. Call it once. func (f *Future[T]) Await(ctx context.Context) (T, error) { select { case r := <-f.ch:4 return r.val, r.err case <-ctx.Done(): var zero T return zero, ctx.Err() } }

public ProductPage load(String sku) { // ❌ each join() waits before the next call even starts Product p = CompletableFuture.supplyAsync(() -> catalog.find(sku)).join(); Price price = CompletableFuture.supplyAsync(() -> pricing.priceFor(sku)).join(); List<Review> rs = CompletableFuture.supplyAsync(() -> reviews.top(sku, 5)).join(); // ❌ no executor -> blocking I/O on ForkJoinPool.commonPool return new ProductPage(p, price, rs); }