otro ejemplo de select y case: https://tour.golang.org/concurrency/5
Case
Introducción
Características esenciales de Go
Qué aprenderás y qué necesitas saber
Repaso general: variables, condicionales, slices y map
Repaso general: GoRoutines y apuntadores
Programación orientada a objetos
¿Es Go orientado a objetos?
Structs vs. clases
Métodos y funciones
Constructores
Herencia
Interfaces
Aplicando interfaces con Abstract Factory
Implementación final de Abstract Factory
Funciones anónimas
Funciones variadicas y retornos con nombre
Go Modules
Cómo utilizar los Go modules
Creando nuestro módulo
Testing
Testing
Code coverage
Profiling
Testing usando Mocks
Implementando Mocks
Concurrencia
Unbuffered channels y buffered channels
Waitgroup
Buffered channels como semáforos
Definiendo channels de lectura y escritura
Worker pools
Multiplexación con Select y Case
Proyecto: servidor con worker pools
Definiendo workers, jobs y dispatchers
Creando web server para procesar jobs
Conclusión
Continúa con el Curso de Go Avanzado
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Iniciar sesiónMultiplexación con Select y Case
27/30Recursos
Aportes 5
Preguntas 0
Ordenar por:
Code:
package main
import (
"fmt"
"time"
)
func doSomething(i time.Duration, c chan<- int, param int) {
time.Sleep(i)
c <- param
}
func main() {
c1 := make(chan int)
c2 := make(chan int)
d1 := 4 * time.Second
d2 := 2 * time.Second
go doSomething(d1, c1, 1)
go doSomething(d2, c2, 2)
for i := 0; i < 2; i++ {
select {
case channelMsg1 := <-c1:
fmt.Println(channelMsg1)
case channelMsg2 := <-c2:
fmt.Println(channelMsg2)
}
}
}
package main
import (
"fmt"
"time"
)
func doSomething(i time.Duration, c chan<- int, param int) {
time.Sleep(i)
c <- param
}
func main() {
c1 := make(chan int)
c2 := make(chan int)
d1 := 4 * time.Second
d2 := 2 * time.Second
go doSomething(d1, c1, 1)
go doSomething(d2, c2, 2)
/* fmt.Println("Waiting for the first result")
fmt.Println(<-c1)
fmt.Println("Waiting for the second result")
fmt.Println(<-c2) */
for i := 0; i < 2; i++ {
select {
case res := <-c1:
fmt.Println("Received", res, "from c1")
case res := <-c2:
fmt.Println("Received", res, "from c2")
}
}
}
Code
package main
import (
"fmt"
"math/rand"
"time"
)
func doSomething(i time.Duration, c chan<- int, param int) {
time.Sleep(i)
c <- param
}
func main() {
c1 := make(chan int)
c2 := make(chan int)
// generate random number
rand.Seed(time.Now().UnixNano())
d1 := time.Duration(rand.Intn(10)) * time.Second
d2 := time.Duration(rand.Intn(10)) * time.Second
go doSomething(d1, c1, 1)
go doSomething(d2, c2, 2)
/* fmt.Println("Waiting for the first result")
fmt.Println(<-c1)
fmt.Println("Waiting for the second result")
fmt.Println(<-c2) */
for i := 0; i < 2; i++ {
// wait for the completion of tasks
select {
case res := <-c1:
fmt.Println("Received", res, "from c1 after", d1)
case res := <-c2:
fmt.Println("Received", res, "from c2 after", d2)
}
}
}
En Go también tenemos el default case como los tradicionales switch-case 🔥
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?
o inicia sesión.