Implementación de Goroutines y channels

Clase 26 de 42 • Curso Práctico de Go: Creación de un Servidor Web

Contenido del curso

Introducción a Go

Nuestra Primera Aplicación Go

Lista de Tareas

Interfaces

Goroutines y Channels

Construyendo un Servidor Web

Tomar examen

Comentarios

Edward Trigos Lopez

student•

Si se incluye "fmt.Println(<- chanel)" en el mismo ciclo for del "go" no se obtiene el mismo rendimiento.

for _, server := range servers {
	go checkServer(server, chanel)
	fmt.Println(&lt;- chanel)
}

Cristian Felipe Patiño Cáceres

student•

Esto me pareció realmente curioso, ya que el canal se recibe en un ciclo también pensé en reutilizar el anterior ciclo para este propósito pero prácticamente queda como si fuera secuencial :O

Jaime Andres Valencia Gaviria

student•

esto es porque espera de manera lineal cada canal si lo hacer asi

Nicoll Idaly Angulo Mejia

student•

Quería aclarar algunas cosas

La primera vez que ejecuta el programa, no aparecen los mensajes, porque primero se acaba de ejecutar el main, que las subrutinas, esto se podría solucionar con un sleep que es muy mala practica, un waitgroup que espera que se ejecuten todas las gorutinas https://gobyexample.com/waitgroups o con canales
Como esta tarea no requiere compartir las respuestas entre las go rutinas waitgroup es una muy buena opción
Quisiera aclarar que la go rutina no va a esperar hasta que acabe la primera para continuar. Trataré de explicarlo

Si tenemos dos gorutinas , que tiene que ejecutar una función

 --  Go rutina 1 
 --  Go rutina 2

func Sumar(num1, num2 int){
	imprime un mensaje
	hace la suma 
	la envia por el canal 
	c <- resultado
}

el proceso sería asi:

Ambas gorutinas empiezan, imprimen, suman, pero al momento de enviar por el canal la primera envia porque nadie ha usado el canal, pero la segunda se queda en pausa, esperando que la primera envie la información, cuando ya el mensaje haya sido recibido por alguien, ahi si la segunda envie su mensaje

Se puede hacer el for de la siguiente manera

 for elem := range queue {
        fmt.Println(elem)
    }

Avelino Sánchez

student•

La palabra clave go lo que hace es crear un nuevo proceso o hilo que se ejecuta independiente de main.

Main al mandar a ejecutar goroutines, aunque no hayan acabado, termina la ejecución de su código. Channels es el mecanismo de comunicación entre las mismas goroutines y también el proceso main.

// definición de un channel.
c := make(chan string)

// sintaxis para transmitir información al channel
c &lt;- &quot;sending data&quot;

// sintaxis para recibir información del channel
received := &lt;-c

Los channels alojan un tipo específico de dato que se debe definir explícitamente.

Si únicamente pusiéramos una vez la recepción de información de un channel, main continuaría con su ejecución, porque no especificamos que tenía que esperar más información. Para recibir la información de múltiples goroutines, tenemos que definir las veces que nuestro channel debe esperar información.

Por otro lado, si no recibiera información se quedaría bloqueado, porque utilizamos un channel de tipo unbuffered, un tipo de channel que no definimos su capacidad o tamaño de manera explícita, que se quedaría esperando a recibir un información.

Jesus David Jinete Clemow

student•

Me pueden ayudar para saber porque me sale el error to many arguments in call to checkStatusServer have (string, chan string) want (string)

El codigo con el ejercicio funcionó de maravilla pero me quedó la duda de porque a mí si me salió está advertencia y al tutor no.

package main

import (
	&quot;fmt&quot;
	&quot;net/http&quot;
	&quot;time&quot;
)

func main() {
	startWatch := time.Now()
	channel1 := make(chan string)
	servers := []string{
		&quot;http://platzi.com&quot;,
		&quot;http://google.com&quot;,
		&quot;http://facebook.com&quot;,
		&quot;http://instagram.com&quot;,
	}

	for _, server := range servers {
		go checkStatusServer(server, channel1)

	}

	for index, _ := range servers {
		fmt.Println(&lt;-channel1, index+1)
	}

	timeExec := time.Since(startWatch)

	fmt.Printf(&quot;Execution time: %s&quot;, timeExec)
}

func checkStatusServer(server string, channel chan string) {
	_, err := http.Get(server)
	if err != nil {
		//fmt.Println(server, &quot;Is not Available =(&quot;)
		channel &lt;- server + &quot; Is not Available =(&quot;
	} else {
		//fmt.Println(server, &quot;It's working OK&quot;)
		channel &lt;- server + &quot; It's working OK&quot;
	}
}

Nicolas Lopez

student•

No se sí es la respuesta, pero si te fijas, declaraste chanstring todo junto, podes revisar que sea eso

Daniel G Perico Sánchez

student•

Después de 7 meses llegó alguien a responderte porque me pasó igual, casi me vuelo loco. El error lo obtuviste porque el otro archivo servidores.go también lo tenías en la misma carpeta y posiblemente abierto. Ese error te lo mostraba porque en el otro archivo estaba la misma función declarada pero tan sólo recibia un parámetro y en el archivo actual le estabamos pasando dos parámetros. Es decir te mostraba el error para la función de otro archivo.Un pequeño bug que no afecta la ejecución del programa.

Daniel Berrospi Carmona

student•

Qué pasaría sí 2 o más gorutinas escriben en un canal antes de que la rutina principal procese al primero? una de esas 2 asignaciones de gorutinas se pierden o el canal actúa como una cola almacenando las asignaciones??

Juan Diego Medina Naranjo

student•

No se si estoy mal, pero sin las rutinas el proceso tomo 2.086 segundos, y usando rutinas tomo 2.736 segundos, entonces no veo la mejora al usar las Goroutines o no se implementarion bien, porque aunque los servidores no siempre responden en un tiempo fijo la idea idea era mejorar los tiempos y 0.7seg es bastante para los llamados

Diego Castro Plazas

student•

Hola Diego!

Intenta medir el tiempo de ejecución únicamente en la función revisarServidor. Y lo comparas contra el tiempo total de ejecución del programa. Así mismo intenta agregar más servidores.

Con esto la comparación es mucho más evidente.

Saludos!

Fabian Gutierrez

student•

esto es por platzi se demora casi 3 segundos en responder. el es el causante de las mayores trabas en el proceso secuencial. prueba a añadir una gran cantidad de urls y ver que tal te va con las diferencias en tiempo entre uno y otro.

Steven Javier Arevalo Poveda

student•

Les comparto el mismo codigo pero con waiting groups ;)

package main

import (
	"fmt"
	"net/http"
	"sync"
	"time"
)

func main() {
	start := time.Now()

	servers := []string{
		"https://www.festivalestereopicnic.com/",
		"https://www.eltiempo.com/",
		"https://platzi.com/",
	}
	var wg sync.WaitGroup
	for _, server := range servers {
		wg.Add(1)
		go checkServer(server, &wg)
	}
	wg.Wait()
	finalTime := time.Since(start)
	fmt.Println("Execution time", finalTime)
}

func checkServer(server string, wg *sync.WaitGroup) {
	_, err := http.Get(server)
	if err != nil {
		fmt.Println(server, "Not available")
	} else {
		fmt.Println(server, "Is UP :) ")
	}
	wg.Done()
}

Usuario anónimo

user•

Se nota la diferencia :)

Juan Pablo Rodríguez Morales

student•

¿Es síncrono o asíncrono? Se me hace que es más síncrono porque no esperamos la ejecución de A para continuar con B, todo corre al tiempo, ¿no es así?

Erik Elyager

student•

Síncronos va mas de cosas que correr de forma coordinada por lo general de forma serial. En go se tiene hilos o thread gracias a las goroutines que permiten aprovechar los núcleos del procesador para correr asíncronismo real. No veamos el asyncronismo como un proceso que corre a partir de otros, más bien es poder tener procesos independientes corriendo a la vez.

Mateo Tavera

student•

Funcionaria igual si se usa un buffered channel de capacidad 4?

Jhon Marco Achata Limachi

student•

Si, funcionaria igual.

Laura Sanabria

student•

Por qué cuando se puso a imprimir el canal desde el main ahí si se imprimen los dos mensajes? no debería solo imprimir el mensaje que se le asignó al canal? Para el caso del ejemplo, se supone que no debería imprimir el texto: "servidorX está funcionando normalmente =)"

Mario Peña

student•

Les dejo mi código, chequea cada link cada 5 segundos.

package main

import (
	"fmt"
	"net/http"
	"time"
)

func main() {
	URLS := []string{
		"platzi",
		"google",
		"facebook",
		"instagram",
	}
	c := make(chan string, len(URLS))

	for _, u := range URLS {
		c <- u
	}

	for u := range c {
		go reviewServer(u, c)
	}
}

func reviewServer(u string, c chan<- string) {
	_, err := http.Get(u)
	if err != nil {
		fmt.Println(u, "is down.")
	} else {
		fmt.Println(u, "is up.")
	}

	time.Sleep(5 * time.Second)
	c <- u
}

Steven Javier Arevalo Poveda

student•

¿Es posible iterar sobre el canal con un for range?

Carlos Nassif Trejo Garcia

student•

package main

import (
	"fmt"
	"net/http"
	"time"
)

func main() {
	inicio := time.Now()

	ch := make(chan string)
	servidores := []string{
		"h t t p   : / / p  l a tz i . c o m",
		"h t t p : // g o o g le . c o m ",
		"h t t p : / / f ac e b o o k . c o m ",
		"h t t p : / / I n s t a g ra m .   co  m",
	}

	for _, servidor := range servidores {
		go revisarServidor(servidor, ch)
	}

	for i := 0; i < len(servidores); i++ {
		fmt.Println(<-ch)
	}

	tiempoPasado := time.Since(inicio)
	fmt.Printf("Done in %s", tiempoPasado)
}

func revisarServidor(servidor string, ch chan string) {
	_, err := http.Get(servidor)

	if err != nil {
		ch <- servidor + "no esta disponible"
	} else {
		ch <- servidor + "esta funcionando"
	}

}

Osnaider Miranda

student•

package main

import (
	"fmt"
	"net/http"
	"time"
)

func main() {
	channel := make(chan string, 4)
	links := []string{
		"https://www.digitalocean.com",
		"https://jsonplaceholder.typicode.com",
		"https://platzi.com/",
		"https://github.com/",
	}
	start := time.Now()
	go func() {
		for _, url := range links {
			if 	_, err := http.Get(url); err != nil {
				fmt.Println("El servidor esta fuera!")
			} else {
				channel <- fmt.Sprintf("%s --> Ok", url)
			}
		}
		defer close(channel)
	}()

	for msg := range channel {
		fmt.Println(msg)
	}
	end := time.Since(start)
	fmt.Println(end)
}

Carlos Javier Bazan Huaman

student•

la combinación Goroutines y channels hacen de Go un lenguaje muy poderoso.

William Rodriguez

student•

Que poder tan abismal tiene Go routines y que sencillo fue implementarlo. según entiendo Go administra los hilos para no tener que abrir tantos hilos como en otros lenguajes. Esta es una ventaja total de go contra el resto.

Jean Nuñez

student•

Los channel nos dice que paso con la ejecucion de las gorutines

Jean Nuñez

student•

con la palabra reservada **chan string ** no dice que estamos declarando un canal con su tipo de datos

Jean Nuñez

student•

canal es el channel y con la flecha <- lo que esta a la derecha de la flecha sera el contenido de lo que se esta transmitiendo

 --  Go rutina 1 
 --  Go rutina 2

func Sumar(num1, num2 int){
	imprime un mensaje
	hace la suma 
	la envia por el canal 
	c <- resultado
}

el proceso sería asi:

Ambas gorutinas empiezan, imprimen, suman, pero al momento de enviar por el canal la primera envia porque nadie ha usado el canal, pero la segunda se queda en pausa, esperando que la primera envie la información, cuando ya el mensaje haya sido recibido por alguien, ahi si la segunda envie su mensaje

// definición de un channel.
c := make(chan string)

// sintaxis para transmitir información al channel
c &lt;- &quot;sending data&quot;

// sintaxis para recibir información del channel
received := &lt;-c

package main

import (
	&quot;fmt&quot;
	&quot;net/http&quot;
	&quot;time&quot;
)

func main() {
	startWatch := time.Now()
	channel1 := make(chan string)
	servers := []string{
		&quot;http://platzi.com&quot;,
		&quot;http://google.com&quot;,
		&quot;http://facebook.com&quot;,
		&quot;http://instagram.com&quot;,
	}

	for _, server := range servers {
		go checkStatusServer(server, channel1)

	}

	for index, _ := range servers {
		fmt.Println(&lt;-channel1, index+1)
	}

	timeExec := time.Since(startWatch)

	fmt.Printf(&quot;Execution time: %s&quot;, timeExec)
}

func checkStatusServer(server string, channel chan string) {
	_, err := http.Get(server)
	if err != nil {
		//fmt.Println(server, &quot;Is not Available =(&quot;)
		channel &lt;- server + &quot; Is not Available =(&quot;
	} else {
		//fmt.Println(server, &quot;It's working OK&quot;)
		channel &lt;- server + &quot; It's working OK&quot;
	}
}

package main

import (
	"fmt"
	"net/http"
	"sync"
	"time"
)

func main() {
	start := time.Now()

	servers := []string{
		"https://www.festivalestereopicnic.com/",
		"https://www.eltiempo.com/",
		"https://platzi.com/",
	}
	var wg sync.WaitGroup
	for _, server := range servers {
		wg.Add(1)
		go checkServer(server, &wg)
	}
	wg.Wait()
	finalTime := time.Since(start)
	fmt.Println("Execution time", finalTime)
}

func checkServer(server string, wg *sync.WaitGroup) {
	_, err := http.Get(server)
	if err != nil {
		fmt.Println(server, "Not available")
	} else {
		fmt.Println(server, "Is UP :) ")
	}
	wg.Done()
}

package main

import (
	"fmt"
	"net/http"
	"time"
)

func main() {
	URLS := []string{
		"platzi",
		"google",
		"facebook",
		"instagram",
	}
	c := make(chan string, len(URLS))

	for _, u := range URLS {
		c <- u
	}

	for u := range c {
		go reviewServer(u, c)
	}
}

func reviewServer(u string, c chan<- string) {
	_, err := http.Get(u)
	if err != nil {
		fmt.Println(u, "is down.")
	} else {
		fmt.Println(u, "is up.")
	}

	time.Sleep(5 * time.Second)
	c <- u
}

package main

import (
	"fmt"
	"net/http"
	"time"
)

func main() {
	inicio := time.Now()

	ch := make(chan string)
	servidores := []string{
		"h t t p   : / / p  l a tz i . c o m",
		"h t t p : // g o o g le . c o m ",
		"h t t p : / / f ac e b o o k . c o m ",
		"h t t p : / / I n s t a g ra m .   co  m",
	}

	for _, servidor := range servidores {
		go revisarServidor(servidor, ch)
	}

	for i := 0; i < len(servidores); i++ {
		fmt.Println(<-ch)
	}

	tiempoPasado := time.Since(inicio)
	fmt.Printf("Done in %s", tiempoPasado)
}

func revisarServidor(servidor string, ch chan string) {
	_, err := http.Get(servidor)

	if err != nil {
		ch <- servidor + "no esta disponible"
	} else {
		ch <- servidor + "esta funcionando"
	}

}

package main

import (
	"fmt"
	"net/http"
	"time"
)

func main() {
	channel := make(chan string, 4)
	links := []string{
		"https://www.digitalocean.com",
		"https://jsonplaceholder.typicode.com",
		"https://platzi.com/",
		"https://github.com/",
	}
	start := time.Now()
	go func() {
		for _, url := range links {
			if 	_, err := http.Get(url); err != nil {
				fmt.Println("El servidor esta fuera!")
			} else {
				channel <- fmt.Sprintf("%s --> Ok", url)
			}
		}
		defer close(channel)
	}()

	for msg := range channel {
		fmt.Println(msg)
	}
	end := time.Since(start)
	fmt.Println(end)
}

Implementación de Goroutines y channels

Introducción a Go

Mi primer programa en Go

Instalación en Mac y Windows

Instalar VS Code

Comandos básicos de Go

Analizando un programa en Go

Nuestra Primera Aplicación Go

Descripción del proyecto 1: Calculadora

Leer inputs desde la consola

Manejo de errores y uso de If

Switch

Lista de Tareas

Structs y Receivers

Descripción del proyecto 2: Lista de Tareas

Structs para Lista de Tareas

Punteros

Punteros en Structs

Uso de Slices

Ciclo For

Implementar For en Struct

Interfaces

¿Qué es una interfaz?

Maps

¿Por qué las Interfaces?

Creando la Interfaz Animal

Imprimiendo el contenido de una Página Web usando Interfaces

Goroutines y Channels

Introducción al problema de la Concurrencia

GoRoutines

Channels

Implementación de Goroutines y channels

Construyendo un Servidor Web

Ciclos While y For

Descripción de Servidor Web

Creando el Servidor

Manejando rutas en backend

¿Qué es un Middleware?

Manejando Request HTTP

Asignando Rutas HTTP

Agregando Middlewares

Agregando Multiples Middlewares

Agregando otro Middleware

Manejando POST

Manejando Modelos y JSON

Respondiendo Request JSON

Go Modules creando nuestro primer módulo en Go

Implementando nuestro primer módulo en Go

Conclusiones del Curso y siguientes pasos