Go Routines, Canales y Apuntadores en Golang

Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Contenido del curso

Introducción

Programación orientada a objetos

Go Modules

Testing

Concurrencia

Proyecto: servidor con worker pools

Conclusión

30
Resumen del Curso Avanzado de Go: Módulos, Tests y Concurrencia
02:34 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:005:56

Go Routines, Canales y Apuntadores en Golang

Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Clase 4 de 30

Clase 4 / 30

Recursos

Comprender cómo funcionan las goroutines, los canales y los apuntadores es fundamental para escribir programas concurrentes y eficientes en Go. A continuación se explican estos tres pilares con ejemplos prácticos extraídos directamente del código trabajado en la sesión.

¿Por qué una goroutine no imprime nada si no usamos canales?

Una goroutine se crea anteponiendo la palabra reservada go antes de la llamada a una función [0:18]. En el ejemplo se define una función llamada doSomething que pone a dormir el proceso durante tres segundos con time.Sleep y luego imprime done.

go func doSomething() { time.Sleep(3 * time.Second) fmt.Println("done") }

Al invocarla con go doSomething(), la función se ejecuta en una rutina diferente a la de main [0:33]. El problema es que main no espera a que doSomething termine: el programa finaliza antes de que pasen los tres segundos y el mensaje done nunca aparece en pantalla [0:48].

¿Cómo se comunican goroutines mediante canales?

Para resolver este problema se emplea un canal (channel). Un canal permite enviar y recibir valores entre goroutines, actuando como mecanismo de sincronización [1:02].

Se crea un canal de tipo entero: c := make(chan int).
Se modifica doSomething para que reciba ese canal como parámetro.
Dentro de la función se envía un valor al canal con el operador <-: c <- 1 [1:22].
En main, la lectura del canal (<-c) bloquea la ejecución hasta que el mensaje llegue [1:32].

go func doSomething(c chan int) { time.Sleep(3 * time.Second) fmt.Println("done") c <- 1 }

func main() { c := make(chan int) go doSomething(c) <-c }

Al ejecutar el programa, los tres segundos transcurren y el done se imprime correctamente [1:42]. La lección clave es que crear una goroutine no basta; se necesita un canal u otro mecanismo para coordinar la comunicación entre rutinas [1:55].

¿Qué diferencia hay entre un apuntador y un valor en Go?

Un apuntador (pointer) almacena la dirección de memoria de otra variable en lugar de su valor directo [2:08].

¿Cómo se crean y se leen apuntadores?

Se declara una variable g con valor 25. Para obtener su apuntador se utiliza el operador ampersand (&) [2:18]:

go g := 25 h := &g fmt.Println(h) // imprime la dirección de memoria, por ejemplo 0xc0000b4008

Si se imprime h directamente, Go muestra la dirección de memoria donde está alojado g [2:38]. Para acceder al valor real almacenado en esa dirección se usa el operador asterisco (*) [2:50]:

go fmt.Println(*h) // imprime 25

&g: devuelve la referencia (dirección de memoria) de g.
*h: devuelve el valor almacenado en la dirección a la que apunta h.

Confundir estos dos operadores puede provocar errores difíciles de rastrear, por lo que conviene tener claro cuándo se trabaja con la dirección y cuándo con el valor [3:08].

¿Qué sintaxis esencial conviene recordar?

Estos son los elementos revisados y su propósito:

go + función: lanza una goroutine.
make(chan tipo): crea un canal del tipo indicado.
canal <- valor: envía un dato al canal.
<-canal: recibe un dato del canal y bloquea hasta obtenerlo.
&variable: obtiene el apuntador (dirección de memoria).
*apuntador: accede al valor almacenado en la dirección.

Dominar estos fundamentos prepara el camino para temas más avanzados como la programación orientada a objetos en Go, que es justamente lo que sigue en el curso [3:30]. Si alguno de estos conceptos te generó dudas, comparte tu experiencia en los comentarios.

Comentarios (13)13 comentarios

Guillermo Pedro Cuneo

Hace 5 años

Codigo acumulado de las clases:

package main

import (
	"fmt"
	"strconv"
	"time"
)

func main() {
	var x int
	x = 8
	y := 7
	fmt.Println(x)
	fmt.Println(y)

	// Capturando valor y error
	myValue, err := strconv.ParseInt("NaN", 0, 64)

	// Validando errores.
	if err != nil {
		fmt.Println("%v\n", err)
	} else {
		fmt.Println(myValue)
	}

	// Mapa clave valor.
	m := make(map[string]int)
	m["key"] = 6
	fmt.Println(m["key"])

	// Slice de enteros.
	s := []int{1, 2, 3}
	for index, value := range s {
		fmt.Println(index)
		fmt.Println(value)
	}
	s = append(s, 16)
	for index, value := range s {
		fmt.Println(index)
		fmt.Println(value)
	}

	//c := make(chan int)
	//go doSomething(c)
	//<-c

	g := 25
	fmt.Println(g) // imprime el valor entero 25
	h := &g
	fmt.Println(h) // imprimer la direccion de memoria.
	i := *h
	fmt.Println(i) // Imprime el valor por de g
}

func doSomething(c chan int) {
	time.Sleep(3 * time.Second)
	fmt.Println("done")
	c <- 1
}

Nicoll Idaly Angulo Mejia

Gorutines and chanels

package main

import "time"

func main() {
	c := make(chan int)
	go doSomething(c)
	go doOtherThing()
	go doSomething(c)
	<- c
	print("Lo imprimirá?")

}

func doSomething(c chan int)  {
	time.Sleep(3 * time.Second)
	println("Do something")
	c <- 1
}

func doOtherThing(){
	println("quien se imprimirá primero?")
}

Benjamin Eduardo De La Torre Rojas

Codigo de esta clase comentado y explicado:

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int) //Creamos un canal para monitorear las Goroutines
	go doSomething(c)   //Llamamos a la función con go para generar un Goroutine
	<-c                 //main esperara a que este canal reciba el mensaje

	g := 25
	fmt.Println(g)
	h := &g         //Apuntador a g
	fmt.Println(h)  //Dirección de memoria donde esta almacenada g
	fmt.Println(*h) //Accedemos al valor de h que a su vez almacena g
}

func doSomething(c chan int) { //Recibimos un canal de tipo int
	time.Sleep(3 * time.Second) //Poner a dormir
	fmt.Println("Done")
	c <- 1 // le envia el valor de 1
}

Jonay Medina

En la parte de Apuntador tambien hay que tener en cuenta que si es cambiado el valor de "g" , la variable "h" tambien tendra el nuevo valor de g

g := 25

fmt.Println(g)

h := &g
fmt.Println(h)
fmt.Println(*h)
g = g + 50
fmt.Println("g:", g, " h: ", *h) \\ g: 75 h: 75

Manuel G. Pineda

Hace 4 años

Totalmente de acuerdo!

María Sol Battaglia

Aca dejo otro ejemplo simple de lo que es una goroutine Go con ejemplos

Xavier Flores

Hace 2 años

Le doy 5🌟 a JS por tener una manera tan sencilla de trabajar el asincronismo. Hasta ahora en GO solo veo su sintaxis muy rústica y poco amigable con el dev. Puede ser su performance un punto muy fuerte a la hora de destacar, pero solo por eso..

Juan Fernando Sánchez Suarez

en "Lecturas recomendadas" el vinculo de "... Servidor web..." esta roto.. 404

Juan Diego Gutierrez Quintana

Hace 3 años

Aun no entiendo muy bien, que son exactamente los gorutines, por que se imprime "done" y no 1?

Emmanuel Rodríguez

Hola 👋

Entiendo la confusión.

Puedes ver a una Go routine como un proceso que se ejecuta concurrentemente (una manera asíncrona de trabajar). Sin tanto rodeos, son ejecuciones de trabajo ligeros, que se comunican o emiten señales mediante canales y pudiendo hacer programación funcional.

Victor Hugo Cruz Carballo

package main

import (
	"fmt"
	"strconv"
	"time"
)

func main() {
	var x int
	x = 5
	fmt.Println(x)

	myValue, error := strconv.ParseInt("y", 0, 8)

	if error != nil {
		fmt.Printf("%v\n", error)
	} else {
		fmt.Println(myValue)
	}

	mapa := make(map[string]int)

	mapa["llave"] = 15

	fmt.Println(mapa["llave"])

	mySlice := []int{6, 5, 4}

	for index, value := range mySlice {
		fmt.Println(index)
		fmt.Println(value)
	}

	mySlice = append(mySlice, 12)
	for index, value := range mySlice {
		fmt.Println(index)
		fmt.Println(value)
	}

	/*miCanal := make(chan int)
	go doSomething(miCanal)
	<-miCanal*/

	g := 25
	fmt.Println(g)

	h := &g
	fmt.Println(h)
	fmt.Println(*h)

}

func doSomething(canal chan int) {
	time.Sleep(3 * time.Second)
	fmt.Println("Listo")
	canal <- 1
}

Moises Abel Avila Garcia

gracias x el aporte

Carlos Nassif Trejo Garcia

package main

import (
	"fmt"
	"strconv"
	"time"
)

func main() {
	var x int
	x = 8
	y := 7

	fmt.Println(x)
	fmt.Println(y)

	// Handling errors
	myValue, err := strconv.ParseInt("Nan", 0, 64)
	if err != nil {
		fmt.Printf("%v\n", err)
	} else {
		fmt.Printf("%v\n", myValue)
	}

	// Map
	m := make(map[string]int)
	m["Key"] = 6
	fmt.Println(m["Key"])

	// Slice
	s := []int{1, 2, 3, 4, 5}
	for i, v := range s {
		fmt.Println(i, v)
	}

	fmt.Println()

	// Append slice
	s = append(s, 6)

	// Range
	for i, v := range s {
		fmt.Println(i, v)
	}

	fmt.Println()

	// Delete from slice
	s = append(s[:2], s[3:]...)

	// Range
	for i, v := range s {
		fmt.Println(i, v)
	}

	// Struct
	type Person struct {
		Name string
		Age  int
	}
	p := Person{"Bob", 20}
	fmt.Println(p.Name)
	fmt.Println(p.Age)

	// Pointer
	var p2 *Person
	p2 = &p
	fmt.Println(p2.Name)
	fmt.Println(p2.Age)

	fmt.Println()

	// Go routines
	c := make(chan int)
	go doSomething(c)

	fmt.Println(<-c)

	fmt.Println()

	// More pointers
	g := 25
	fmt.Println(g)
	h := &g
	fmt.Println(*h)

	*h = 30
	fmt.Println(g)

}

func doSomething(c chan int) {
	fmt.Println("Doing something")
	time.Sleep(1 * time.Second)
	fmt.Println("Done")

	c <- 1
}

exelente

exelente explicacion , me encanta este curso

Platzi Team

Que gran repaso

Oscar Jaramillo

Excelente repaso

Introducción

Programación Orientada a Objetos y Concurrencia en Go

Concurrencia y Testing en Go: Go Routinas y Worker Pools

Fundamentos de Programación en Go: Structs, Apuntadores y Manejo de Errores

Go Routines, Canales y Apuntadores en Golang

Programación orientada a objetos

Programación Orientada a Objetos en Go: Análisis y Comparativa

Equivalente de Clases en Go: Uso de Structs y Propiedades

Métodos en Structs: Implementación de Receiver Functions en Go

Implementación de Constructores en Go: Ejemplos y Mejores Prácticas

Herencia y Composición en Programación Orientada a Objetos

Interfaces y Polimorfismo en TypeScript y Go

Patrón Abstract Factory: Interfaces y Polimorfismo en Go

Implementación del Patrón Factory en Go para Notificaciones

Funciones Anónimas en Go: Uso y Consideraciones Prácticas

Funciones Variádicas y Retornos con Nombre en Go

Go Modules

Manejo de Dependencias y Módulos en Go

Creación y Publicación de Módulos en GitHub con Go

Testing

Tests unitarios y code coverage en Go

Cobertura de Código y Testing en Go: Mejorando la Calidad del Software

Profiling de Código en Go para Optimización de Rendimiento

Testing Unitario en Go: Uso de Mock Services

Testeo Unitario de Funciones con MOOC en Go

Concurrencia

Canales con y sin buffer en Go: diferencias y uso práctico

Sincronización de Rutinas en Go con Wait Group

"Uso de Canales con Buffer como Semáforos en Go"

Manejo de Canales de Lectura y Escritura en Go

Concurrencia en Go: Creación de Worker Pools y Fibonacci

Multiplexación de Canales en Go con Select y Case

Proyecto: servidor con worker pools

Creación de un Web Server con Worker Pool en Go

Creación de un Servidor Web Concurrente con Go

Conclusión

Resumen del Curso Avanzado de Go: Módulos, Tests y Concurrencia

Go Routines, Canales y Apuntadores en Golang