se centró en la concurrencia nativa del lenguaje Go (Golang), destacando dos pilares fundamentales: las Go Rutinas (Goroutines) y los Canales (Channels). Se definió una Go Rutina como una función ligera y eficiente que permite ejecutar tareas de forma concurrente, facilitando la creación de aplicaciones altamente escalables. A continuación, se explicó cómo los Canales sirvieron como el mecanismo principal para que estas rutinas pudieran comunicarse y sincronizarse de forma segura, siguiendo el principio de «No comuniques compartiendo memoria; comparte memoria comunicando». La píldora incluyó ejemplos prácticos donde se demostró la sintaxis y la potencia de este modelo, ofreciendo a los desarrolladores herramientas para manejar operaciones asíncronas con mayor limpieza y control. 💡

Píldora formativa:

Rutinas y canales en GO

Imparte:

Alex Coll

Go es un lenguaje:

• Tipado: intX y uintX¹, float32/64, byte y rune (alias de uint8 e int32, usados para representar char), boolean, string y complex (similar a float, pero para números complejos).

• Paso de parámetros por valor

• Punteros

• Garbage collector → mark-and-sweep: se marcan los objetos a los que puede referenciar el usuario. Después de esto, se limpiar la heap de objetos no marcados (inalcanzables)

Goroutines

Podemos entender las goroutines como hilos de ejecución². Imaginemos el caso del siguiente programa:

func f(start, end int) {
for i := start; i < end; i++ {
fmt.Println(i) }
}
func main() {
go f(4, 7)
go f(7, 11)
f(1, 4) time.Sleep(time.Second) fmt.Println(«done»)
}

Channels

Los canales son el mecanismo de comunicación entre goroutines. Para el caso anterior, imaginemos que queremos sumar los números en vez de imprimirlos, y enviar el total al canal:

var ch = make(chan int, 3)
func f(start, end int) { total := 0
for i := start; i < end; i++ { total += i
}
ch <- total }
func g() {
for n := range ch {
fmt.Println(«Number «, n) }
}
func main() {
defer close(ch)
go f(4, 7)
go f(7, 11)
f(1, 4)
go g() time.Sleep(time.Second) fmt.Println(«done»)
}

La forma de usar un canal difiere del objetivo que tengamos con él:

• Si es solo escritura, podemos indicar ch chan<-

• Si es solo lectura, ch <-chan

• Si es ambos, ch chan

En cuanto a la creación

ch := make(chan int) → Unbuffered: bloqueante hasta que otra goroutine recibe el valor

ch := make(chan int, 5) → Cuando conocemos la cantidad de datos que vamos a usar

Notas:

1: X puede ser 8, 16, 32 y 64. Si se usa int o uint, es dependiente de la plataforma.

2: Las diferencias entre hilos y goroutines son mínimas:

• Pila: ~2MB fijos para hilos; y 2KB para goroutines (pero puede crecer si es necesario)

• Scheduling: OS para hilos; multiplexación m:n para Go (m goroutines en n hilos)

• Identidad: ID único para hilos; goroutines no tienen

Admin