Đồng thờiConcurrency

Cancellation / Contextaka Context Propagation, Cooperative Cancellation, Deadline Propagation

Truyền tín hiệu huỷ và deadline xuống mọi tác vụ con để không ai làm việc vô ích.Propagate cancel signals and deadlines down to every sub-task so nobody works for nothing.

Độ 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 đặt đồ ăn trên app rồi bấm huỷ. Lệnh huỷ phải tới được nhà hàng (ngừng nấu), tới tài xế (ngừng chạy tới quán) và tới cổng thanh toán (hoàn tiền). Nếu chỉ app biết bạn huỷ còn bếp vẫn nấu, tài xế vẫn chạy — đó là lãng phí. Context chính là 'tờ phiếu order' đi kèm mọi người, ai cũng phải liếc xem nó đã bị gạch chưa.You order food in an app, then hit cancel. The cancel must reach the restaurant (stop cooking), the driver (stop heading over) and the payment gateway (refund). If only the app knows while the kitchen keeps cooking and the driver keeps riding, that's waste. A context is the 'order ticket' everyone carries, and everyone must glance at it to see if it was crossed out.

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

Không có patternWithout the pattern

API báo giá của bạn gọi song song kho hàng và hãng vận chuyển. Client đã timeout sau 2 giây và bỏ đi, nhưng server vẫn chờ hãng vận chuyển thêm 30 giây, giữ connection DB, giữ thread/goroutine. Dưới tải cao, hàng nghìn request 'ma' như vậy chất đống → hết connection pool, goroutine leak, cả hệ thống chậm theo.Your quote API calls inventory and the shipping carrier in parallel. The client gave up after 2 seconds, but the server keeps waiting 30 more seconds for the carrier, holding a DB connection and a thread/goroutine. Under load, thousands of such 'ghost' requests pile up → exhausted connection pools, goroutine leaks, and the whole system slows down.

Với Cancellation / ContextWith Cancellation / Context

Tạo một context (hoặc scope) gắn deadline ở đầu request và TRUYỀN nó xuống mọi lời gọi con. Khi hết giờ, client ngắt, hoặc một tác vụ con lỗi, context bị huỷ: kênh Done() đóng lại và mọi tác vụ đang lắng nghe dừng ngay, trả tài nguyên. Huỷ là 'hợp tác' (cooperative): không ai bị giết cưỡng bức, mỗi tác vụ tự kiểm tra tín hiệu và tự thoát.Create a context (or scope) with a deadline at the start of the request and PASS it down to every sub-call. When time runs out, the client disconnects, or a sub-task fails, the context is cancelled: its Done() channel closes and every listening task stops right away, releasing resources. Cancellation is cooperative: nobody is forcibly killed, each task checks the signal and exits on its own.

Thành phần tham giaParticipants

Root context / Scope: Sinh ra ở đầu request, mang deadline và nút huỷ (cancel).Born at the start of a request, carries the deadline and the cancel button.
Derived context: Context con kế thừa từ cha; cha huỷ thì con huỷ theo, con có thể đặt deadline ngắn hơn.A child context derived from the parent; parent cancel cascades down, a child may set a shorter deadline.
Done signal: Kênh ctx.Done() (Go) hoặc cờ interrupt (Java) báo 'dừng lại'.The ctx.Done() channel (Go) or the interrupt flag (Java) that says 'stop'.
Worker / Sub-task: Goroutine/thread làm việc, PHẢI lắng nghe tín hiệu và dọn dẹp khi bị huỷ.The goroutine/thread doing work; it MUST listen for the signal and clean up when cancelled.

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.

1Request tới. Handler tạo ctx từ r.Context() với timeout 2 giây và defer cancel().A request arrives. The handler derives ctx from r.Context() with a 2-second timeout and defer cancel().

← →

console

1GET /quote/42 → ctx deadline=+2s

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.checkout;

import java.time.Instant;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Subtask;
import java.util.concurrent.TimeoutException;
import org.springframework.stereotype.Service;

// Java 21: StructuredTaskScope is a preview API (--enable-preview)
@Service
public class QuoteService {
    private final StockClient stock;
    private final ShippingClient shipping;

    public QuoteService(StockClient stock, ShippingClient shipping) {
        this.stock = stock;
        this.shipping = shipping;
    }

    public Quote quote(long orderId) throws InterruptedException, TimeoutException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {1
            Subtask<Integer> qty = scope.fork(() -> stock.available(orderId));2
            Subtask<Long> fee = scope.fork(() -> shipping.fee(orderId));

            scope.joinUntil(Instant.now().plusSeconds(2)); // deadline for the whole tree3
            scope.throwIfFailed(QuoteFailedException::new);
            return new Quote(qty.get(), fee.get());
        } // close(): interrupts unfinished subtasks and waits for them4
    }
}

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

package checkout

import (
	"context"
	"errors"
	"net/http"
	"time"

	"golang.org/x/sync/errgroup"
)

func (h *Handler) Quote(w http.ResponseWriter, r *http.Request) {
	// r.Context() is cancelled automatically when the client disconnects
	ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)1
	defer cancel() // always release the timer2

	g, ctx := errgroup.WithContext(ctx)3
	var qty int
	var fee int64
	g.Go(func() (err error) {
		qty, err = h.stock.Available(ctx, r.PathValue("id"))
		return err
	})
	g.Go(func() (err error) {
		fee, err = h.shipping.Fee(ctx, r.PathValue("id"))
		return err
	})

	if err := g.Wait(); err != nil { // first error cancels ctx for the other
		if errors.Is(err, context.DeadlineExceeded) {
			http.Error(w, "upstream timeout", http.StatusGatewayTimeout)
			return
		}
		http.Error(w, err.Error(), http.StatusBadGateway)
		return
	}
	writeJSON(w, Quote{Qty: qty, Fee: fee}) // safe: read after Wait()4
}

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

01Go truyền ctx TƯỜNG MINH qua mọi hàm như tham số đầu tiên. Java không có object tương đương: huỷ dựa trên cờ interrupt của thread, còn deadline thì mỗi tầng (HTTP client, JDBC, @Transactional) cấu hình riêng.Go passes ctx EXPLICITLY through every function as the first parameter. Java has no equivalent object: cancellation relies on the thread's interrupt flag, and each layer (HTTP client, JDBC, @Transactional) configures its own timeout.
02Tín hiệu huỷ của Go là một channel bị đóng — dùng được trong select cùng các channel khác. Java dùng cờ interrupt + InterruptedException từ các lời gọi blocking (sleep, wait, I/O của virtual thread).Go's cancel signal is a closed channel — usable in select alongside other channels. Java uses the interrupt flag + InterruptedException thrown by blocking calls (sleep, wait, virtual-thread I/O).
03errgroup.WithContext (Go) và StructuredTaskScope.ShutdownOnFailure (Java 21 preview) cùng ý tưởng: một tác vụ con lỗi → huỷ các anh em, và cha luôn chờ con thoát hết (structured concurrency).errgroup.WithContext (Go) and StructuredTaskScope.ShutdownOnFailure (Java 21 preview) share one idea: a failing sub-task cancels its siblings, and the parent always waits for all children (structured concurrency).
04Cả hai đều là huỷ HỢP TÁC: Go không giết được goroutine từ bên ngoài, Java cũng không (Thread.stop đã bị loại bỏ). Code không lắng nghe tín hiệu thì không bao giờ dừng.Both are COOPERATIVE: Go can't kill a goroutine from outside, neither can Java (Thread.stop is gone). Code that never listens never stops.
05Go ctx còn mang request-scoped values (trace ID...) qua context.WithValue; Java thường dùng ThreadLocal/MDC hoặc ScopedValue (Java 21 preview).Go ctx also carries request-scoped values (trace ID...) via context.WithValue; Java usually uses ThreadLocal/MDC or ScopedValue (Java 21 preview).

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

net/http, database/sql, gRPC trong GoGo net/http, database/sql, gRPC
r.Context(), db.QueryContext(ctx, ...), http.NewRequestWithContext — cả stdlib xoay quanh ctx. gRPC còn gửi deadline qua mạng (header grpc-timeout) sang service kế tiếp.r.Context(), db.QueryContext(ctx, ...), http.NewRequestWithContext — the whole stdlib revolves around ctx. gRPC even ships the deadline over the wire (grpc-timeout header) to the next service.
Java: Future.cancel, CompletableFuture.orTimeout, StructuredTaskScopeJava: Future.cancel, CompletableFuture.orTimeout, StructuredTaskScope
future.cancel(true) gửi interrupt; orTimeout(2, SECONDS) làm future fail khi quá hạn (nhưng KHÔNG dừng việc bên dưới); StructuredTaskScope huỷ cả cây subtask.future.cancel(true) sends an interrupt; orTimeout(2, SECONDS) fails the future past the deadline (but does NOT stop the underlying work); StructuredTaskScope cancels the whole subtask tree.
Spring: @Transactional(timeout), RestClient, WebFluxSpring: @Transactional(timeout), RestClient, WebFlux
Timeout cấu hình theo tầng. Riêng WebFlux/Reactor: khi client ngắt, subscription bị cancel và tín hiệu huỷ chạy ngược lên chuỗi Mono/Flux — gần với ctx của Go nhất.Timeouts are configured per layer. In WebFlux/Reactor, a client disconnect cancels the subscription and the cancel signal travels up the Mono/Flux chain — the closest thing to Go's ctx.
Tìm chuyến xe / báo giá giao hàngRide search / delivery quotes
App gọi xe hỏi 5 đối tác cùng lúc với deadline 1.5 giây; user đổi điểm đón thì huỷ toàn bộ truy vấn cũ ngay lập tức.A ride app queries 5 partners at once with a 1.5s deadline; when the user changes the pickup point, all old queries are cancelled immediately.

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

Nên dùng khiUse it when

Mọi xử lý gắn với một request có thời hạn (HTTP, gRPC) — gần như mặc định trong Go.Any work tied to a request with a time budget (HTTP, gRPC) — practically the default in Go.
Khi chạy nhiều tác vụ con song song và một cái lỗi thì các cái khác nên dừng.When you run several sub-tasks in parallel and one failing should stop the others.
Goroutine/thread chạy nền dài hạn (polling, consumer) cần cách dừng sạch khi shutdown.Long-lived background goroutines/threads (polling, consumers) that need a clean stop on shutdown.

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

Tác vụ PHẢI chạy hết dù client bỏ đi (ghi sổ cái, gửi hoá đơn) — tách sang context riêng (Go 1.21: context.WithoutCancel) hoặc đẩy vào queue.Work that MUST complete even if the client leaves (ledger writes, invoices) — detach it (Go 1.21: context.WithoutCancel) or push it to a queue.
Đừng dùng context.WithValue làm 'túi đồ' truyền tham số nghiệp vụ — chỉ cho dữ liệu request-scoped như trace ID.Don't use context.WithValue as a bag for business parameters — only for request-scoped data like trace IDs.

Ưu điểmPros

Giải phóng tài nguyên sớm: connection, thread, goroutine không bị giữ vô ích.Releases resources early: connections, threads, goroutines aren't held for nothing.
Một deadline chung cho cả chuỗi gọi — tránh 'timeout cộng dồn' giữa các service.One deadline for the whole call chain — avoids 'stacked timeouts' across services.
Chống goroutine leak và giúp graceful shutdown dễ dàng.Prevents goroutine leaks and makes graceful shutdown easy.

Nhược điểmCons

Lan toả: mọi hàm trên đường đi đều phải nhận và truyền ctx.Viral: every function along the path must accept and pass ctx.
Huỷ chỉ là lời nhắn: code không kiểm tra tín hiệu (vòng lặp CPU, thư viện cũ) vẫn chạy tiếp.Cancellation is only a request: code that never checks (CPU loops, old libraries) keeps running.
Java phân mảnh: interrupt, timeout từng tầng, Reactor cancel — mỗi nơi một kiểu.Fragmented in Java: interrupts, per-layer timeouts, Reactor cancel — each its own style.

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

Cắt đứt chuỗi context và để goroutine mồ côiBreaking the context chain and orphaning goroutines

Dùng context.Background() trong handler làm mất tín hiệu 'client đã ngắt'; bỏ qua cancel làm rò timer; goroutine gửi vào channel không buffer sẽ kẹt mãi khi select đã chọn nhánh timeout. Luôn dẫn xuất từ r.Context() và select kèm ctx.Done().Using context.Background() in a handler loses the 'client disconnected' signal; dropping cancel leaks the timer; a goroutine sending on an unbuffered channel blocks forever once the select took the timeout branch. Always derive from r.Context() and select with ctx.Done().

func (h *Handler) Quote(w http.ResponseWriter, r *http.Request) {
	ctx, _ := context.WithTimeout(context.Background(), 2*time.Second) // ❌ ignores r.Context(), leaks cancel
	result := make(chan int64)
	go func() {
		fee, _ := h.shipping.Fee(ctx, r.PathValue("id"))
		result <- fee // ❌ blocks forever if nobody reads → goroutine leak
	}()
	select {
	case fee := <-result:
		writeJSON(w, fee)
	case <-time.After(time.Second): // ❌ a second, unrelated deadline
		http.Error(w, "timeout", http.StatusGatewayTimeout)
	}
}

Dễ nhầm vớiEasily confused with

Cancellation / Context vs Circuit Breaker

Context/timeout giới hạn MỘT lần gọi và huỷ việc dở dang. Circuit Breaker nhìn thống kê NHIỀU lần gọi để ngừng gọi hẳn một service đang hỏng.Context/timeout bounds ONE call and cancels unfinished work. Circuit Breaker watches stats over MANY calls to stop calling a failing service altogether.

Cancellation / Context vs Future / Promise

Future là 'cái hộp' chứa kết quả tương lai; context là 'tín hiệu' báo hãy dừng tính kết quả đó. Hai thứ thường đi cùng nhau.A Future is the 'box' holding a future result; a context is the 'signal' saying stop computing it. They often go together.

Bài tập áp dụngExercise

Viết hàm FirstQuote(ctx, carriers []Carrier) (Quote, error) hỏi giá song song nhiều hãng vận chuyển, trả về báo giá ĐẦU TIÊN thành công và huỷ ngay các lời gọi còn lại. Không được để goroutine nào leak.Write FirstQuote(ctx, carriers []Carrier) (Quote, error) that asks several carriers in parallel, returns the FIRST successful quote and immediately cancels the remaining calls. No goroutine may leak.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 6Question 1 of 6

Khi ctx bị huỷ, điều gì xảy ra với kênh `ctx.Done()`?When ctx is cancelled, what happens to `ctx.Done()`?

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.

Dùng trong bài toánUsed in problems

2 bài toán Backend dùng pattern này2 backend problems use this pattern

Pattern liên quanRelated patterns

Future / Promise Fan-out / Fan-in Worker Pool Circuit Breaker

Thảo luậnDiscussion

Cancellation / Contextaka Context Propagation, Cooperative Cancellation, Deadline Propagation

Truyền tín hiệu huỷ và deadline xuống mọi tác vụ con để không ai làm việc vô ích.Propagate cancel signals and deadlines down to every sub-task so nobody works for nothing.

VừaMedium

Mức phổ biếnUsage 5/5

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

package com.shop.checkout; import java.time.Instant; import java.util.concurrent.StructuredTaskScope; import java.util.concurrent.StructuredTaskScope.Subtask; import java.util.concurrent.TimeoutException; import org.springframework.stereotype.Service; // Java 21: StructuredTaskScope is a preview API (--enable-preview) @Service public class QuoteService { private final StockClient stock; private final ShippingClient shipping; public QuoteService(StockClient stock, ShippingClient shipping) { this.stock = stock; this.shipping = shipping; } public Quote quote(long orderId) throws InterruptedException, TimeoutException { try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {1 Subtask<Integer> qty = scope.fork(() -> stock.available(orderId));2 Subtask<Long> fee = scope.fork(() -> shipping.fee(orderId)); scope.joinUntil(Instant.now().plusSeconds(2)); // deadline for the whole tree3 scope.throwIfFailed(QuoteFailedException::new); return new Quote(qty.get(), fee.get()); } // close(): interrupts unfinished subtasks and waits for them4 } }

package checkout import ( "context" "errors" "net/http" "time" "golang.org/x/sync/errgroup" ) func (h *Handler) Quote(w http.ResponseWriter, r *http.Request) { // r.Context() is cancelled automatically when the client disconnects ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)1 defer cancel() // always release the timer2 g, ctx := errgroup.WithContext(ctx)3 var qty int var fee int64 g.Go(func() (err error) { qty, err = h.stock.Available(ctx, r.PathValue("id")) return err }) g.Go(func() (err error) { fee, err = h.shipping.Fee(ctx, r.PathValue("id")) return err }) if err := g.Wait(); err != nil { // first error cancels ctx for the other if errors.Is(err, context.DeadlineExceeded) { http.Error(w, "upstream timeout", http.StatusGatewayTimeout) return } http.Error(w, err.Error(), http.StatusBadGateway) return } writeJSON(w, Quote{Qty: qty, Fee: fee}) // safe: read after Wait()4 }

func (h *Handler) Quote(w http.ResponseWriter, r *http.Request) { ctx, _ := context.WithTimeout(context.Background(), 2*time.Second) // ❌ ignores r.Context(), leaks cancel result := make(chan int64) go func() { fee, _ := h.shipping.Fee(ctx, r.PathValue("id")) result <- fee // ❌ blocks forever if nobody reads → goroutine leak }() select { case fee := <-result: writeJSON(w, fee) case <-time.After(time.Second): // ❌ a second, unrelated deadline http.Error(w, "timeout", http.StatusGatewayTimeout) } }

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

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

Thành phần tham giaParticipants

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

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

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

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

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

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

Cắt đứt chuỗi context và để goroutine mồ côiBreaking the context chain and orphaning goroutines

Dễ nhầm vớiEasily confused with

Bài tập áp dụngExercise

Kiểm tra kiến thứcKnowledge check

Khi ctx bị huỷ, điều gì xảy ra với kênh ctx.Done()?When ctx is cancelled, what happens to ctx.Done()?

Thẻ ghi nhớFlashcards

Dùng trong bài toánUsed in problems

Pattern liên quanRelated patterns

Thảo luậnDiscussion

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

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

Thành phần tham giaParticipants

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

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

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

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

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

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

Cắt đứt chuỗi context và để goroutine mồ côiBreaking the context chain and orphaning goroutines

Dễ nhầm vớiEasily confused with

Bài tập áp dụngExercise

Kiểm tra kiến thứcKnowledge check

Khi ctx bị huỷ, điều gì xảy ra với kênh ctx.Done()?When ctx is cancelled, what happens to ctx.Done()?

Thẻ ghi nhớFlashcards

Dùng trong bài toánUsed in problems

Pattern liên quanRelated patterns

Thảo luậnDiscussion

Khi ctx bị huỷ, điều gì xảy ra với kênh `ctx.Done()`?When ctx is cancelled, what happens to `ctx.Done()`?

Khi ctx bị huỷ, điều gì xảy ra với kênh `ctx.Done()`?When ctx is cancelled, what happens to `ctx.Done()`?