Implementando tiempos de espera en Go con canales

Introducción

El propósito de este laboratorio es implementar los tiempos de espera en Go utilizando canales y select.

Tiempos de espera

Los tiempos de espera son importantes para los programas que se conectan a recursos externos o que de otra manera necesitan limitar el tiempo de ejecución. En este laboratorio, se implementarán tiempos de espera en Go utilizando canales y select.

• Implementar tiempos de espera en Go utilizando canales y select.
• Utilizar un canal con búfer para evitar fugas de gorutinas en caso de que el canal nunca se lea.
• Utilizar time.After para esperar a que se envíe un valor después del tiempo de espera.
• Utilizar select para continuar con la primera recepción lista.

## Ejecutar este programa muestra que la primera operación
## agota el tiempo y la segunda tiene éxito.
$ go run timeouts.go
timeout 1
result 2

A continuación, se muestra el código completo:

// Los _tiempos de espera_ son importantes para los programas
// que se conectan a recursos externos o que de otra manera
// necesitan limitar el tiempo de ejecución. Implementar
// tiempos de espera en Go es fácil y elegante gracias a
// los canales y `select`.

package main

import (
	"fmt"
	"time"
)

func main() {

	// Para nuestro ejemplo, supongamos que estamos
	// ejecutando una llamada externa que devuelve su
	// resultado en un canal `c1` después de 2s. Tenga en
	// cuenta que el canal tiene búfer, por lo que el envío
	// en la gorutina no bloquea. Este es un patrón común
	// para evitar fugas de gorutinas en caso de que el
	// canal nunca se lea.
	c1 := make(chan string, 1)
	go func() {
		time.Sleep(2 * time.Second)
		c1 <- "result 1"
	}()

	// Aquí está el `select` que implementa un tiempo de
	// espera. `res := <-c1` espera el resultado y
	// `<-time.After` espera a que se envíe un valor
	// después del tiempo de espera de 1s. Dado que
	// `select` continúa con la primera recepción lista,
	// tomaremos el caso de tiempo de espera si la
	// operación tarda más de los 1s permitidos.
	select {
	case res := <-c1:
		fmt.Println(res)
	case <-time.After(1 * time.Second):
		fmt.Println("timeout 1")
	}

	// Si permitimos un tiempo de espera más largo de 3s,
	// entonces la recepción de `c2` tendrá éxito y
	// mostraremos el resultado.
	c2 := make(chan string, 1)
	go func() {
		time.Sleep(2 * time.Second)
		c2 <- "result 2"
	}()
	select {
	case res := <-c2:
		fmt.Println(res)
	case <-time.After(3 * time.Second):
		fmt.Println("timeout 2")
	}
}

Resumen

En este laboratorio, aprendimos cómo implementar tiempos de espera en Go utilizando canales y select. Utilizamos un canal con búfer para evitar fugas de gorutinas en caso de que el canal nunca se lea, y time.After para esperar a que se envíe un valor después del tiempo de espera. También utilizamos select para continuar con la primera recepción lista.