Goroutine là gì?

Question

Goroutine là gì?

Accepted Answer

Một **goroutine** là một hàm thực thi đồng thời (concurrent), nhẹ, được quản lý bởi Go runtime. Khởi chạy một goroutine đơn giản như đặt `go` trước một lời gọi hàm. Goroutine là tính năng concurrency đặc trưng của Go — rẻ hơn nhiều so với OS thread, nên bạn có thể chạy hàng nghìn hoặc hàng triệu.

## Khởi chạy một goroutine

```go
func sayHello() {
    fmt.Println("Hello from a goroutine")
}

go sayHello()        // khởi chạy đồng thời — main KHÔNG chờ nó
go func() {           // hoặc một hàm vô danh
    fmt.Println("inline goroutine")
}()
```

Từ khóa `go` bắt đầu hàm trên một goroutine mới và trả về ngay lập tức — code gọi tiếp tục mà không chờ.

## Vì sao goroutine đặc biệt: chúng rẻ

```text
OS thread:  ~1–2 MB bộ nhớ mỗi cái → tối đa hàng nghìn
Goroutine:  ~2 KB stack ban đầu (tăng theo nhu cầu) → khả thi HÀNG TRIỆU
Go runtime LẬP LỊCH nhiều goroutine lên một pool nhỏ các OS thread (M:N).
```

Goroutine không phải là OS thread — Go scheduler ghép nhiều goroutine lên một vài OS thread. Điều này khiến chúng cực kỳ rẻ, cho phép concurrency lớn (ví dụ, một goroutine mỗi kết nối trong một server xử lý hàng triệu kết nối).

## Vấn đề đồng bộ hóa: main có thể thoát quá sớm

```go
func main() {
    go sayHello()    // ❌ main có thể THOÁT trước khi goroutine này chạy → không in gì
    // chương trình kết thúc ngay lập tức
}
```

Khi `main` trả về, chương trình kết thúc — kết liễu mọi goroutine còn đang chạy. Bạn cần điều phối.

## Chờ với sync.WaitGroup

```go
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)                    // tăng bộ đếm
    go func(n int) {
        defer wg.Done()          // giảm khi goroutine này hoàn tất
        fmt.Println("worker", n)
    }(i)                          // truyền i như tham số (tránh lỗi bắt biến vòng lặp)
}
wg.Wait()                         // CHẶN cho đến khi tất cả goroutine gọi Done()
```

`sync.WaitGroup` là cách chuẩn để chờ một tập goroutine hoàn tất.

## Giao tiếp với channel

```go
ch := make(chan string)
go func() { ch <- "result" }()   // gửi một kết quả lên channel
msg := <-ch                       // nhận (chặn cho đến khi có giá trị đến)
```

Triết lý Go: **"Đừng giao tiếp bằng cách chia sẻ bộ nhớ; hãy chia sẻ bộ nhớ bằng cách giao tiếp"** — dùng channel để truyền dữ liệu giữa các goroutine thay vì biến chung + khóa.

## Tại sao điều này quan trọng

Goroutine là tính năng đặc trưng của Go và là lý do chính khiến nó vượt trội ở các hệ thống concurrent, có kết nối mạng.

Sự nhẹ nhàng cực độ của chúng (kilobyte so với megabyte cho thread, được lập lịch M:N lên các OS thread) khiến concurrency quy mô lớn trở nên thực tế và dễ dàng — một server có thể tạo một goroutine mỗi request hoặc kết nối mà không lo ngại tài nguyên, điều khó hoặc không thể với OS thread.

Hiểu cách khởi chạy chúng (`go`), nhu cầu thiết yếu phải **đồng bộ hóa** (main thoát sẽ kết liễu goroutine; dùng `WaitGroup` để chờ), và sự ưa thích của Go đối với **giao tiếp qua channel** thay vì bộ nhớ chung là nền tảng để viết Go concurrent đúng đắn.

Goroutine (và các pattern xoay quanh chúng) là trung tâm của giá trị cốt lõi của Go và nằm trong số các chủ đề quan trọng và được kiểm tra thường xuyên nhất của ngôn ngữ.