Câu lệnh select trong Golang: timeout, default và kênh quit

Chờ trên nhiều channel

select trông giống switch, nhưng mỗi case là một thao tác gửi hoặc nhận trên channel. Nó chặn cho đến khi có một case thực hiện được rồi chạy case đó.

package main

import (
	"fmt"
	"time"
)

func main() {
	fast := make(chan string)
	slow := make(chan string)

	go func() {
		time.Sleep(30 * time.Millisecond)
		slow <- "slow result"
	}()
	go func() {
		time.Sleep(10 * time.Millisecond)
		fast <- "fast result"
	}()

	for range 2 {
		select {
		case msg := <-fast:
			fmt.Println("from fast:", msg)
		case msg := <-slow:
			fmt.Println("from slow:", msg)
		}
	}
}

Với độ trễ như trên, select đầu tiên nhận kết quả nhanh và select thứ hai nhận kết quả chậm. Không thao tác nhận nào phải chờ channel còn lại. Nếu viết <-slow rồi đến <-fast, chúng sẽ được xử lý theo thứ tự cố định, bất kể cái nào đến trước.

Cách select đánh giá:

1. Mọi biểu thức channel và giá trị cần gửi được tính một lần, theo thứ tự trong mã nguồn, khi select bắt đầu.
2. Nếu có một hoặc nhiều case sẵn sàng, một trong số đó được chọn ngẫu nhiên.
3. Nếu không case nào sẵn sàng và có default, default sẽ chạy.
4. Nếu không, goroutine bị chặn cho đến khi có case sẵn sàng.

Một select {} rỗng chặn mãi mãi. Thỉnh thoảng bạn gặp nó ở cuối main trong những chương trình mà công việc thật diễn ra ở các goroutine khác.

Chọn ngẫu nhiên giữa các case sẵn sàng

Khi nhiều case sẵn sàng cùng lúc, select không ưu tiên case được viết đầu tiên. Chương trình này lấp đầy hai channel có bộ đệm rồi chạy select 1000 lần:

package main

import "fmt"

func main() {
	a := make(chan int, 1000)
	b := make(chan int, 1000)
	for range 1000 {
		a <- 1
		b <- 1
	}

	countA, countB := 0, 0
	for range 1000 {
		select {
		case <-a:
			countA++
		case <-b:
			countB++
		}
	}
	fmt.Println("both channels were picked:", countA > 0 && countB > 0)
	fmt.Println("total:", countA+countB)
}

Tỷ lệ giữa countA và countB thay đổi sau mỗi lần chạy và xoay quanh 500 mỗi bên. Việc chọn ngẫu nhiên là có chủ đích: nó ngăn một channel bận rộn làm các channel khác bị bỏ đói. Nếu cần ưu tiên, hãy xem mẫu ở phần dưới.

Thao tác không chặn với default

Có case default, select không bao giờ chặn. Nhờ đó một thao tác gửi hay nhận trở thành thao tác "thử":

package main

import "fmt"

func main() {
	queue := make(chan int, 2)

	for i := 1; i <= 3; i++ {
		select {
		case queue <- i:
			fmt.Println("queued", i)
		default:
			fmt.Println("queue full, dropped", i)
		}
	}

	for {
		select {
		case v := <-queue:
			fmt.Println("got", v)
		default:
			fmt.Println("queue empty")
			return
		}
	}
}

Bỏ bớt công việc khi bộ đệm đầy là cách giảm tải hoặc gửi số liệu đo mà không bao giờ làm nơi gọi bị đứng.

Đừng đặt default vào một select nằm trong vòng for chỉ để "kiểm tra" các channel liên tục. Khi không có gì sẵn sàng, vòng lặp quay liên tục và chiếm 100% CPU. Hãy để nó chặn, và thêm một case timeout nếu cần thức dậy định kỳ.

Timeout

time.After(d) trả về một channel nhận được giá trị một lần sau khoảng d. Cho nó chạy đua với công việc thật:

package main

import (
	"errors"
	"fmt"
	"time"
)

var errTimeout = errors.New("timed out")

func fetch(delay time.Duration) (string, error) {
	result := make(chan string, 1) // buffered: the worker can finish even if nobody reads
	go func() {
		time.Sleep(delay) // pretend to call something slow
		result <- "data"
	}()

	select {
	case r := <-result:
		return r, nil
	case <-time.After(50 * time.Millisecond):
		return "", errTimeout
	}
}

func main() {
	for _, d := range []time.Duration{10 * time.Millisecond, 200 * time.Millisecond} {
		r, err := fetch(d)
		fmt.Printf("result=%q err=%v\n", r, err)
	}
}

Lần gọi đầu trả về "data". Lần gọi thứ hai trả về lỗi timeout sau 50 ms, rất lâu trước khi worker kịp xong. Channel kết quả có bộ đệm 1 là có chủ đích. Khi timeout thắng, không ai nhận từ result nữa; nếu channel không có bộ đệm, goroutine worker sẽ bị chặn mãi ở thao tác gửi và bị rò rỉ.

Trong vòng lặp, time.After tạo một bộ hẹn giờ mới ở mỗi lần lặp, đúng như cần cho timeout chờ theo từng tin nhắn ("không có tin nhắn trong 1 giây"). Với một deadline chung cho nhiều thao tác, hãy tạo một bộ hẹn giờ hoặc context duy nhất trước vòng lặp. Từ Go 1.23, các bộ hẹn giờ không còn được tham chiếu sẽ được thu gom rác dù chưa kích hoạt, nên time.After trong vòng lặp không còn giữ bộ nhớ cho đến khi từng bộ hẹn giờ kích hoạt như ở các phiên bản cũ (cần khai báo go 1.23 trở lên trong go.mod).

Vòng lặp for-select và kênh quit

Một goroutine chạy cho đến khi được bảo dừng là một vòng for bao quanh select, với một case cho công việc và một case để dừng:

package main

import "fmt"

func worker(jobs <-chan int, quit <-chan struct{}, done chan<- struct{}) {
	defer close(done)
	for {
		select {
		case j := <-jobs:
			fmt.Println("processing job", j)
		case <-quit:
			fmt.Println("worker: stopping")
			return
		}
	}
}

func main() {
	jobs := make(chan int)
	quit := make(chan struct{})
	done := make(chan struct{})

	go worker(jobs, quit, done)
	for i := 1; i <= 3; i++ {
		jobs <- i
	}
	close(quit) // closing wakes every goroutine that selects on quit
	<-done
	fmt.Println("main: worker has exited")
}

Đóng quit thay vì gửi vào nó là cách viết chuẩn: lệnh đóng được mọi bên nhận nhìn thấy, cả bây giờ lẫn sau này, nên một lệnh close dừng được bao nhiêu worker cũng được. Channel done cho phép main chờ đến khi worker thật sự kết thúc.

Trong code thực tế, kênh quit thường là một context.Context: case <-ctx.Done():. Nó hoạt động y như vậy (Done() trả về một channel bị đóng khi bị hủy) và còn mang theo deadline cùng lý do dừng. Trang về context sẽ giải thích chi tiết.

break bên trong select

break trong một case của select chỉ thoát khỏi select, không thoát khỏi vòng for bao quanh. Đây là nguyên nhân phổ biến khiến vòng lặp không bao giờ kết thúc. Hãy dùng return, hoặc gắn nhãn cho vòng lặp:

package main

import "fmt"

func main() {
	nums := make(chan int)
	go func() {
		defer close(nums)
		for i := range 5 {
			nums <- i
		}
	}()

	sum := 0
loop:
	for {
		select {
		case n, ok := <-nums:
			if !ok {
				break loop // without the label this only leaves the select
			}
			sum += n
		}
	}
	fmt.Println("sum:", sum)
}

Ưu tiên giữa các channel

Vì select chọn ngẫu nhiên, bạn không thể xếp hạng các case trong cùng một câu lệnh. Để một channel luôn thắng mỗi khi có dữ liệu, hãy kiểm tra riêng nó trước:

for {
	select {
	case <-ctx.Done():
		return ctx.Err()
	default:
	}

	select {
	case <-ctx.Done():
		return ctx.Err()
	case job := <-jobs:
		handle(job)
	}
}

select đầu tiên trả về ngay nếu việc hủy đã xảy ra. Nếu không có nó, một dòng công việc đều đặn có thể tiếp tục thắng lượt chọn ngẫu nhiên trong một lúc sau khi ctx đã bị hủy.

Channel nil vô hiệu hóa một case

Gửi hay nhận trên một channel nil không bao giờ sẵn sàng, nên case trên channel nil coi như bị tắt. Gán nil cho một đầu vào đã đóng là cách ngừng select trên nó mà vẫn tiếp tục với các channel khác; trang về channel có một vòng lặp gộp được viết theo cách này. Mẹo này cũng dùng để bật tắt timeout: giữ var timeout <-chan time.Time ở giá trị nil cho đến khi cần, rồi gán time.After(d).

Lỗi thường gặp

• Tưởng select theo thứ tự trong mã nguồn. Case viết đầu tiên không được ưu tiên.
• Vòng lặp bận với default. Một for { select { ... default: } } không có việc gì làm sẽ đốt cạn một nhân CPU.
• Rò rỉ bên thua. Khi timeout thắng, goroutine lẽ ra gửi kết quả vẫn phải kết thúc được. Hãy cho channel của nó bộ đệm 1.
• break chỉ thoát khỏi select. Dùng nhãn hoặc return.
• Mỗi lần lặp một time.After nhưng lại dùng làm deadline chung. Nó bắt đầu lại ở mỗi lần lặp; hãy tạo deadline một lần, bên ngoài vòng lặp.