Channel hoạt động như thế nào?

Question

Accepted Answer

Một **channel** là một đường ống có kiểu (typed) cho **giao tiếp giữa các goroutine** — một goroutine gửi giá trị, một goroutine khác nhận chúng. Channel là cách các goroutine Go truyền dữ liệu an toàn và đồng bộ hóa, thể hiện phương châm "chia sẻ bộ nhớ bằng cách giao tiếp".

## Tạo và sử dụng channel

```go
ch := make(chan int)     // một channel int không có buffer

go func() {
    ch <- 42             // GỬI một giá trị vào channel (mũi tên trỏ VÀO ch)
}()

value := <-ch            // NHẬN một giá trị từ channel (mũi tên trỏ RA)
fmt.Println(value)       // 42
```

Toán tử `<-` vừa gửi (`ch <- v`) vừa nhận (`v := <-ch`).

## Channel không buffer vs có buffer

```go
// KHÔNG BUFFER — việc gửi chặn cho đến khi có bên nhận sẵn sàng (điểm đồng bộ hóa)
ch := make(chan int)
// việc gửi chặn cho đến khi một goroutine khác nhận → chúng "gặp nhau"

// CÓ BUFFER — giữ tối đa N giá trị; việc gửi chỉ chặn khi buffer ĐẦY
buf := make(chan int, 3)
buf <- 1; buf <- 2; buf <- 3   // những lệnh này không chặn (buffer còn chỗ)
buf <- 4                        // chặn ngay bây giờ — buffer đã đầy
```

Channel **không buffer** đồng bộ hóa: một lệnh gửi chờ một lệnh nhận (và ngược lại), khiến chúng trở thành một công cụ điều phối. Channel **có buffer** tách rời bên gửi và bên nhận đến mức kích thước buffer.

## Đóng channel và ranging

```go
ch := make(chan int)
go func() {
    for i := 0; i < 3; i++ { ch <- i }
    close(ch)               // báo hiệu "không còn giá trị" (chỉ bên GỬI đóng)
}()

for v := range ch {         // nhận cho đến khi channel ĐƯỢC ĐÓNG
    fmt.Println(v)
}

// dạng comma-ok phát hiện một channel đã đóng
v, ok := <-ch               // ok = false nếu channel đã đóng và đã cạn
```

Đóng một channel báo hiệu hoàn thành; `range` trên một channel nhận cho đến khi nó được đóng. **Chỉ bên gửi nên đóng** một channel.

## Các cạm bẫy deadlock và panic phổ biến

```go
// ❌ deadlock — gửi trên một channel không buffer mà không có bên nhận
ch := make(chan int)
ch <- 1                     // 💥 fatal error: all goroutines asleep - deadlock!

// ❌ panic — thao tác trên/sau khi đóng
close(ch); close(ch)        // 💥 panic: close of closed channel
close(ch); ch <- 1          // 💥 panic: send on closed channel
v := <-closedCh             // ✅ OK — nhận từ channel đã đóng trả về giá trị zero
```

Deadlock (mọi người đều bị chặn) và các panic liên quan đến việc đóng là các lỗi channel phổ biến cần hiểu.

## Channel có hướng (cho API rõ ràng)

```go
func producer(out chan<- int) { out <- 1 }   // chỉ gửi
func consumer(in <-chan int)  { <-in }         // chỉ nhận
```

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

Channel là trái tim của mô hình concurrency của Go và là cách idiomatic để các goroutine giao tiếp và đồng bộ hóa — hiện thực triết lý cốt lõi "đừ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".

Chúng cho phép bạn truyền dữ liệu an toàn giữa các goroutine concurrent mà không cần khóa tường minh, xây dựng pipeline, phân phối công việc, và báo hiệu hoàn thành.

Hiểu các thao tác gửi/nhận, sự phân biệt quan trọng **không buffer (đồng bộ hóa) vs có buffer (tách rời)**, ngữ nghĩa đóng (bên gửi đóng; range/comma-ok phát hiện), và các cạm bẫy phổ biến (**deadlock** từ gửi/nhận bị chặn, **panic** từ việc đóng hai lần hoặc gửi trên channel đã đóng) là thiết yếu để viết Go concurrent đúng đắn.

Channel (cùng với goroutine) là trung tâm bản sắc của Go và nằm trong số các khái niệm quan trọng và được kiểm tra thường xuyên nhất của ngôn ngữ.