Dokumentacja Go z przykładami: Instrukcja select

Q: Co robi select w Go?

select czeka, aż jedna z jego operacji na kanałach (wysłanie lub odbiór) będzie mogła się wykonać, i wtedy uruchamia ten przypadek. Jeśli kilka jest gotowych jednocześnie, wybiera jeden losowo. Bez przypadku default blokuje się, dopóki któryś przypadek nie będzie gotowy; z default nigdy się nie blokuje.

Q: Jak dodać timeout do odbioru z kanału w Go?

Umieść odbiór i timer w jednym select: select { case v := <-ch: use(v); case <-time.After(2 * time.Second): return errTimeout }. Wygrywa to, co nastąpi pierwsze. W pętli albo gdy wywołujący ma już deadline, użyj zamiast tego context.Context z context.WithTimeout i czekaj w select na ctx.Done().

Q: Czy select w Go wybiera przypadki po kolei?

Nie. Gdy gotowy jest więcej niż jeden przypadek, Go wybiera losowo z równym prawdopodobieństwem, więc żaden przypadek nie może zagłodzić pozostałych. Jeśli potrzebujesz priorytetu, najpierw sprawdź kanał o wysokim priorytecie we własnym select z default, a dopiero potem przejdź do select po wszystkich kanałach.

Q: Dlaczego break nie wychodzi z mojej pętli for-select?

Wewnątrz select instrukcja break wychodzi tylko z select, a nie z otaczającej pętli for. Użyj return albo dodaj etykietę do pętli (loop: for { select { case <-done: break loop } }).

Czekanie na kilka kanałów

select wygląda jak switch, ale każdy przypadek to wysłanie do kanału lub odbiór z niego. Blokuje się, aż jeden przypadek będzie mógł się wykonać, i wtedy go uruchamia.

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)
		}
	}
}

Przy tych opóźnieniach pierwszy select dostaje szybki wynik, a drugi wolny. Żaden odbiór nie musi czekać na drugi kanał. Zwykłe <-slow, a po nim <-fast obsłużyłyby je w stałej kolejności, bez względu na to, który przyszedł pierwszy.

Jak select jest wykonywany:

Wszystkie wyrażenia kanałów i wartości do wysłania są obliczane raz, w kolejności z kodu, gdy select się zaczyna.
Jeśli gotowy jest jeden lub więcej przypadków, jeden z nich jest wybierany losowo.
Jeśli żaden nie jest gotowy, a istnieje default, wykonuje się default.
W przeciwnym razie goroutine blokuje się, dopóki któryś przypadek nie stanie się gotowy.

Pusty select {} blokuje na zawsze. Czasem widać go na końcu main w programach, których właściwa praca odbywa się w innych goroutine.

Losowy wybór spośród gotowych przypadków

Gdy kilka przypadków jest gotowych jednocześnie, select nie preferuje pierwszego z listy. Ten program wypełnia dwa buforowane kanały, a potem wykonuje select 1000 razy:

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)
}

Podział między countA a countB zmienia się przy każdym uruchomieniu i wychodzi blisko 500 dla każdego. Losowy wybór jest zamierzony: zapobiega temu, by zajęty kanał zagłodził pozostałe. Jeśli potrzebujesz priorytetu, zobacz wzorzec niżej.

Operacje nieblokujące z default

Z przypadkiem default instrukcja select nigdy się nie blokuje. To zamienia wysłanie lub odbiór w operację typu „spróbuj”:

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
		}
	}
}

Porzucanie pracy, gdy bufor jest pełny, to sposób na zrzucanie nadmiaru obciążenia albo wysyłanie metryk bez wstrzymywania wywołującego.

Nie wstawiaj default do select w pętli for tylko po to, żeby w kółko „sprawdzać” kanały. Gdy nic nie jest gotowe, pętla kręci się na 100% CPU. Zamiast tego blokuj i dodaj przypadek z timeoutem, jeśli musisz się okresowo wybudzać.

Timeouty

time.After(d) zwraca kanał, który odbiera wartość raz, po czasie d. Postaw go do wyścigu z właściwą pracą:

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)
	}
}

Pierwsze wywołanie zwraca "data". Drugie zwraca błąd timeoutu po 50 ms, na długo zanim worker by skończył. Kanał wyniku ma celowo bufor o rozmiarze 1. Gdy wygrywa timeout, nikt nigdy nie odbiera z result; przy kanale niebuforowanym goroutine workera zablokowałaby się na wysyłaniu na zawsze i wyciekłaby.

W pętli time.After tworzy nowy timer w każdej iteracji, co jest dokładnie tym, czego chcesz dla timeoutu bezczynności na wiadomość („brak wiadomości przez 1 sekundę”). Dla łącznego deadline'u obejmującego wiele operacji utwórz jeden timer lub kontekst przed pętlą. Od Go 1.23 timery, do których nie ma już odwołań, są zbierane przez garbage collector, nawet jeśli jeszcze nie odpaliły, więc time.After w pętli nie trzyma już pamięci do odpalenia każdego timera, jak w starszych wersjach (wymaga to go 1.23 lub nowszego w go.mod).

Pętle for-select i kanały quit

Goroutine, która działa, dopóki nie dostanie polecenia zatrzymania, to pętla for wokół select z jednym przypadkiem dla pracy i jednym dla zatrzymania:

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")
}

Idiomem jest zamknięcie quit zamiast wysyłania do niego: zamknięcie widzi każdy odbiorca, teraz i później, więc jedno close zatrzymuje dowolną liczbę workerów. Kanał done pozwala main poczekać, aż worker naprawdę się zakończy.

W prawdziwym kodzie kanałem quit jest zwykle context.Context: case <-ctx.Done():. Działa tak samo (Done() zwraca kanał, który jest zamykany przy anulowaniu), a do tego przenosi deadline'y i powód zatrzymania. Opisuje to strona o kontekście.

break wewnątrz select

break w przypadku select wychodzi z select, a nie z otaczającej pętli for. To częste źródło pętli, które nigdy się nie kończą. Użyj return albo dodaj etykietę do pętli:

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)
}

Priorytet między kanałami

Ponieważ select wybiera losowo, w jednej instrukcji nie da się ustalić kolejności przypadków. Aby jeden kanał wygrywał zawsze, gdy ma coś do odebrania, sprawdź go najpierw osobno:

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

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

Pierwszy select od razu kończy funkcję, jeśli anulowanie już nastąpiło. Bez niego stały strumień zadań mógłby jeszcze przez jakiś czas wygrywać losowanie po anulowaniu ctx.

Kanały nil wyłączają przypadek

Wysłanie lub odbiór na kanale nil nigdy nie jest gotowe, więc przypadek z kanałem nil jest w praktyce wyłączony. Ustawienie zamkniętego wejścia na nil to sposób, by przestać na nie czekać w select i dalej obsługiwać pozostałe; strona o kanałach pokazuje zbudowaną w ten sposób pętlę scalającą. Ta sama sztuczka włącza i wyłącza timeout: trzymaj var timeout <-chan time.Time jako nil, dopóki go nie potrzebujesz, a potem przypisz time.After(d).

Typowe błędy

Oczekiwanie kolejności z kodu. Pierwszy przypadek na liście nie jest preferowany.
Pętla aktywnego oczekiwania z default. for { select { ... default: } } bez pracy do wykonania pali cały rdzeń CPU.
Wyciek przegranej goroutine. Gdy wygrywa timeout, goroutine, która miała wysłać wynik, nadal musi móc się zakończyć. Daj jej kanałowi bufor o rozmiarze 1.
break, który wychodzi tylko z select. Użyj etykiety lub return.
Jedno time.After na iterację pętli użyte jako łączny deadline. Restartuje się w każdej iteracji; utwórz deadline raz, poza pętlą.

Najczęściej zadawane pytania

Co robi select w Go?

select czeka, aż jedna z jego operacji na kanałach (wysłanie lub odbiór) będzie mogła się wykonać, i wtedy uruchamia ten przypadek. Jeśli kilka jest gotowych jednocześnie, wybiera jeden losowo. Bez przypadku default blokuje się, dopóki któryś przypadek nie będzie gotowy; z default nigdy się nie blokuje.

Jak dodać timeout do odbioru z kanału w Go?

Umieść odbiór i timer w jednym select: select { case v := <-ch: use(v); case <-time.After(2 * time.Second): return errTimeout }. Wygrywa to, co nastąpi pierwsze. W pętli albo gdy wywołujący ma już deadline, użyj zamiast tego context.Context z context.WithTimeout i czekaj w select na ctx.Done().

Czy select w Go wybiera przypadki po kolei?

Nie. Gdy gotowy jest więcej niż jeden przypadek, Go wybiera losowo z równym prawdopodobieństwem, więc żaden przypadek nie może zagłodzić pozostałych. Jeśli potrzebujesz priorytetu, najpierw sprawdź kanał o wysokim priorytecie we własnym select z default, a dopiero potem przejdź do select po wszystkich kanałach.

Dlaczego break nie wychodzi z mojej pętli for-select?

Wewnątrz select instrukcja break wychodzi tylko z select, a nie z otaczającej pętli for. Użyj return albo dodaj etykietę do pętli (loop: for { select { case <-done: break loop } }).

Powiązane zagadnienia