Guida Go interattiva: Istruzione select

Q: Cosa fa select in Go?

select aspetta finché una delle sue operazioni sui canali (un invio o una ricezione) può procedere, poi esegue quel caso. Se più casi sono pronti nello stesso momento ne sceglie uno a caso. Senza un caso default si blocca finché un caso non è pronto; con default non si blocca mai.

Q: Come aggiungo un timeout alla ricezione da un canale in Go?

Metti la ricezione e un timer nello stesso select: select { case v := <-ch: use(v); case <-time.After(2 * time.Second): return errTimeout }. Vince chi arriva prima. Dentro un ciclo, o quando il chiamante ha già una scadenza, usa invece un context.Context con context.WithTimeout e fai select su ctx.Done().

Q: select in Go sceglie i casi in ordine?

No. Quando più di un caso è pronto, Go sceglie in modo uniformemente casuale, così nessun caso può affamare gli altri. Se ti serve una priorità, controlla prima il canale prioritario in un suo select con un default, poi passa a un select su tutti i canali.

Q: Perché break non esce dal mio ciclo for-select?

Dentro un select, break esce solo dall'istruzione select, non dal for che la contiene. Usa return, oppure metti un'etichetta sul ciclo (loop: for { select { case <-done: break loop } }).

Attendere più canali

select somiglia a uno switch, ma ogni caso è un invio o una ricezione su un canale. Si blocca finché un caso non può procedere e poi esegue quello.

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

Con questi ritardi il primo select riceve il risultato veloce e il secondo quello lento. Nessuna delle due ricezioni deve aspettare l'altro canale. Un semplice <-slow seguito da <-fast li gestirebbe in un ordine fisso, indipendentemente da quale arrivi prima.

Come viene valutato select:

Tutte le espressioni dei canali e i valori da inviare vengono valutati una sola volta, nell'ordine del sorgente, quando parte il select.
Se uno o più casi sono pronti, ne viene scelto uno a caso.
Se nessuno è pronto e c'è un default, viene eseguito il default.
Altrimenti la goroutine si blocca finché un caso non diventa pronto.

Un select {} vuoto si blocca per sempre. Ogni tanto lo trovi alla fine di main in programmi il cui lavoro vero avviene in altre goroutine.

Scelta casuale tra i casi pronti

Quando più casi sono pronti nello stesso momento, select non preferisce il primo della lista. Questo programma riempie due canali con buffer e poi esegue select 1000 volte:

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

La ripartizione tra countA e countB cambia a ogni esecuzione e si aggira intorno a 500 ciascuno. La scelta casuale è voluta: impedisce che un canale molto attivo affami gli altri. Se ti serve una priorità, guarda lo schema più avanti.

Operazioni non bloccanti con default

Con un caso default, select non si blocca mai. Questo trasforma un invio o una ricezione in un'operazione di "tentativo":

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

Scartare il lavoro quando un buffer è pieno è il modo per ridurre il carico o emettere metriche senza mai bloccare il chiamante.

Non mettere un default in un select dentro un ciclo for solo per "controllare" i canali di continuo. Se non c'è niente di pronto, il ciclo gira a vuoto al 100% della CPU. Blocca invece, e aggiungi un caso di timeout se devi svegliarti periodicamente.

Timeout

time.After(d) restituisce un canale che riceve un valore una volta dopo d. Mettilo in gara con il lavoro vero:

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

La prima chiamata restituisce "data". La seconda restituisce l'errore di timeout dopo 50 ms, molto prima che il worker abbia finito. Il canale del risultato ha un buffer di 1 di proposito. Quando vince il timeout nessuno riceve mai da result; con un canale senza buffer la goroutine del worker resterebbe bloccata per sempre sul suo invio, causando un leak.

In un ciclo, time.After crea un nuovo timer a ogni iterazione, ed è esattamente quello che serve per un timeout di inattività per messaggio ("nessun messaggio per 1 secondo"). Per una scadenza complessiva su molte operazioni, crea un solo timer o context prima del ciclo. Da Go 1.23 i timer non più referenziati vengono raccolti dal garbage collector anche se non sono scattati, quindi time.After in un ciclo non trattiene più memoria finché ogni timer non scatta, come succedeva nelle versioni precedenti (serve go 1.23 o successivo in go.mod).

Cicli for-select e canali di uscita

Una goroutine che gira finché non le si dice di fermarsi è un ciclo for attorno a un select con un caso per il lavoro e uno per l'arresto:

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

Chiudere quit invece di inviarci un valore è l'idioma: una chiusura viene vista da ogni ricevente, ora e in futuro, quindi un solo close ferma qualsiasi numero di worker. Il canale done permette a main di aspettare che il worker sia davvero terminato.

Nel codice reale il canale di uscita di solito è un context.Context: case <-ctx.Done():. Funziona allo stesso modo (Done() restituisce un canale che viene chiuso alla cancellazione) e in più porta con sé scadenze e il motivo dell'arresto. La pagina su context lo tratta in dettaglio.

break dentro select

break in un caso di select esce dal select, non dal for che lo contiene. È una fonte comune di cicli che non finiscono mai. Usa return, oppure metti un'etichetta sul ciclo:

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

Priorità tra canali

Dato che select sceglie a caso, non puoi dare un ordine ai casi dentro una sola istruzione. Per far vincere un canale ogni volta che ha qualcosa, controllalo prima da solo:

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

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

Il primo select ritorna subito se la cancellazione è già avvenuta. Senza di esso, un flusso costante di job potrebbe continuare a vincere la scelta casuale per un po' dopo la cancellazione di ctx.

I canali nil disattivano un caso

Un invio o una ricezione su un canale nil non è mai pronto, quindi un caso su un canale nil è di fatto spento. Impostare a nil un input chiuso è il modo per smettere di fare select su di esso continuando con gli altri; la pagina sui canali mostra un ciclo di merge costruito così. Lo stesso trucco accende e spegne un timeout: tieni var timeout <-chan time.Time a nil finché non ti serve, poi assegnagli time.After(d).

Errori comuni

Aspettarsi l'ordine del sorgente. Il primo caso della lista non ha la precedenza.
Un ciclo attivo con default. Un for { select { ... default: } } senza niente da fare consuma un core della CPU.
Lasciare in sospeso chi perde. Quando vince un timeout, la goroutine che avrebbe inviato il risultato deve comunque poter finire. Dai al suo canale un buffer di 1.
Un break che esce solo dal select. Usa un'etichetta o return.
Un time.After per iterazione usato come scadenza complessiva. Riparte a ogni iterazione; crea la scadenza una volta sola, fuori dal ciclo.

Domande frequenti

Cosa fa select in Go?

select aspetta finché una delle sue operazioni sui canali (un invio o una ricezione) può procedere, poi esegue quel caso. Se più casi sono pronti nello stesso momento ne sceglie uno a caso. Senza un caso default si blocca finché un caso non è pronto; con default non si blocca mai.

Come aggiungo un timeout alla ricezione da un canale in Go?

Metti la ricezione e un timer nello stesso select: select { case v := <-ch: use(v); case <-time.After(2 * time.Second): return errTimeout }. Vince chi arriva prima. Dentro un ciclo, o quando il chiamante ha già una scadenza, usa invece un context.Context con context.WithTimeout e fai select su ctx.Done().

select in Go sceglie i casi in ordine?

No. Quando più di un caso è pronto, Go sceglie in modo uniformemente casuale, così nessun caso può affamare gli altri. Se ti serve una priorità, controlla prima il canale prioritario in un suo select con un default, poi passa a un select su tutti i canali.

Perché break non esce dal mio ciclo for-select?

Dentro un select, break esce solo dall'istruzione select, non dal for che la contiene. Usa return, oppure metti un'etichetta sul ciclo (loop: for { select { case <-done: break loop } }).

Concetti correlati