Go Concurrency Distilled es un nuevo mini-libro que transforma los primitivos de concurrencia de Go en un conjunto de ejemplos interactivos que puede modificar y ejecutar directamente en la página. El libro cubre goroutines, canales, select, grupos de espera, mutexes, semáforos y más, cada uno con fragmentos de código en vivo que puede editar y ejecutar. También existe una versión en PDF con ejemplos estáticos para imprimir o leer sin conexión.
El libro se describe como una actualización rápida, no una guía para principiantes. Para una inmersión más profunda, el autor dirige a los lectores a Gist of Go: Concurrencia, un libro separado con ejercicios prácticos. Todo el proyecto está libre de IA, lo que el autor señala explícitamente.
Goroutines y Grupos de Espera
Goroutines are the building blocks of Go concurrency. You start one with the go keyword, and the Go runtime juggles them across operating system threads running on CPU cores. Goroutines are lighter than OS threads, so you can create hundreds or thousands of them without much overhead.
In the example above, two goroutines print «worker 1» and «worker 2» after being launched. A wait group (sync.WaitGroup) tracks their completion. The Add method sets the counter, Done decrements it, and Wait blocks until the counter reaches zero. That keeps the main function from exiting until both workers are finished.
There’s also a WaitGroup.Go method that combines the setup. It increments the counter, runs the function in a goroutine, and decrements the counter when the function ends.
Canales y Direcciones de Canal
Los canales permiten que las goroutines pasen valores entre sí. Un canal es una ventana donde una goroutine lanza un valor y otra lo recibe. Enviar un valor a través de un canal es sincrónico: la goroutine que envía se bloquea hasta que la goroutine que recibe toma el valor.
The book shows a simple example where a goroutine sends «ping» to a channel, and the main function reads it back. The sender blocks on ch <- val, and the receiver blocks on <-ch. Only when the value is received does the sending goroutine continue.
Cuando un canal ya no es necesario, el recolector de basura de Go libera automáticamente sus recursos, ya esté cerrado o no. Cerrar un canal indica a los lectores que se ha enviado todo el dato. El lector verifica el estado del canal con un segundo valor, llamado estado «coma OK».
Así es como el lector verifica:
go
num, ok := <-in
if !ok {
break
}
If ok is false, the channel is closed and the loop stops. If ok is true, the reader gets the next value.
Canales Direccionales y Canales con Buffer
Channels can be bidirectional, send-only, or receive-only. Bidirectional channels are the default. Send-only channels can be declared with chan<- int, and receive-only channels are declared with <-chan int.
No se puede leer de un canal solo de envío ni escribir en un canal solo de recepción, y no se puede cerrar un canal solo de recepción. Establecer la dirección protege contra errores accidentales.
Los canales con buffer actúan como una cola FIFO con un búfer de tamaño fijo. Escribir en un canal con buffer no se bloquea siempre que haya espacio en el búfer, y leer no se bloquea siempre que el búfer contenga valores.
The cap and len functions work on buffered channels. cap shows the buffer size, and len shows how many values are currently stored.
Reading from a closed buffered channel works the same way as a regular channel. It returns values from the buffer until the buffer is empty, then returns a zero value with ok set to false.
Lo que Ofrece Este Libro
El formato interactivo es el atractivo. En lugar de leer sobre concurrencia, puede cambiar el código y ver los resultados de inmediato. Eso importa para un tema donde el tiempo y el orden de los eventos a menudo son difíciles de comprender solo a partir de texto.
El libro también es notable por la ausencia de participación de la IA. En un campo donde las herramientas automatizadas están en todas partes, esta es una elección deliberada del autor, y vale la pena señalarla junto con el contenido técnico.
| Tema | Detalle Clave |
|---|---|
| Gorrutinas | Started with the go keyword; tracked by sync.WaitGroup |
| Canales | Values passed synchronously; closed with close(ch) |
| Canales con búfer | FIFO queue with fixed buffer size; use cap and len |
| Canales direccionales | chan<- for send-only, <-chan for receive-only |
El libro es una lectura rápida para cualquiera que ya conozca Go pero desee afinar su comprensión de la concurrencia. No es un sustituto del completo Gist de Go: Concurrencia, al que el autor dirige a los principiantes, pero es un complemento útil para el desarrollador experimentado que busca un repaso rápido.
Los ejemplos interactivos son la joya de la corona. Modificar la lógica de una gorrutina y ver cómo cambia la salida en segundos es más rápido que leer un muro de prosa.
El libro es una adición bienvenida al ecosistema de Go. Hace que un tema complejo sea accesible a través de ejemplos pequeños y ejecutables, y lo hace sin depender de la automatización. Esa combinación —interacción práctica y diseño cuidadoso— es lo suficientemente rara como para justificar una mirada.
Material de origen: “Go Concurrency Distilled,” antonz.org.
Recibe El Cuaderno.
Las mejores historias del día y cada veredicto nuevo, en español claro, en tu correo a las siete. Un correo al día, nada más.