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

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:0011:23

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

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

Clase 26 de 30

Clase 26 / 30

Recursos

¿Qué es Workerpool en Go y cómo puede transformar tus proyectos?

El mundo de la programación es vasto y está lleno de paradigmas interesantes. Uno de los conceptos más poderosos en el lenguaje de programación Go es el de workerpool, que permite la ejecución concurrente de tareas específicas por múltiples "trabajadores" o workers. Por tanto, es esencial entender cómo implementar esto en tus proyectos para optimizar tareas que demandan tiempo. ¡Veamos cómo funciona en Go!

¿Cómo se inicia un proyecto de workerpool en Go?

El primer paso es crear un archivo en Go, por ejemplo, wp.go. Dicho archivo comenzará como la mayoría de los programas en Go, definiendo el paquete con la clausula package main. Luego, se definirá una función para el cálculo de la serie de Fibonacci. Esta función, que utiliza una implementación recursiva, será la pieza central del trabajo que realizarán los trabajadores.

func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

¿Cómo se crea un worker en Go?

Un worker es una función que recibe tareas (jobs) a través de un canal, las procesa y envía el resultado a través de otro canal. Es fundamental asignar un ID a cada worker para identificar qué trabajador realiza cada tarea.

func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, job)
        results <- fibonacci(job)
        fmt.Printf("Worker %d finished job %d\n", id, job)
    }
}

¿Cómo implementar el workerpool en la función principal?

La función main es donde se coordina todo el proceso: definir las tareas, crear los canales de comunicación, iniciar los workers y manejar los resultados.

Definir las tareas: Se utiliza un slice para almacenar los números a los que se les aplicará la serie de Fibonacci.
Configurar los workers: Crear varios workers, asignándoles un ID y pasando los canales de tareas y resultados.
Manejar los canales: Asignar las tareas a los workers a través de un canal y recibir los resultados por otro.

func main() {
    tasks := []int{2, 3, 4, 5, 7, 10, 12, 40}
    numOfWorkers := 3

    jobs := make(chan int, len(tasks))
    results := make(chan int, len(tasks))

    for w := 1; w <= numOfWorkers; w++ {
        go worker(w, jobs, results)
    }

    for _, task := range tasks {
        jobs <- task
    }
    close(jobs)

    for i := 0; i < len(tasks); i++ {
        <-results
    }
}

¿Cómo optimiza el uso de go rutinas y canales en Go?

La magia de Go se encuentra en su capacidad para manejar la concurrencia de manera eficiente y sencilla. Al utilizar go rutinas y canales de comunicación, es posible crear programas altamente concurrentes sin la complejidad que otros lenguajes requieren. Cada worker es manejado como una gorutina, procesando tareas de manera concurrente y colaborando mediante canales de comunicación.

Esta estructura no solo mejora el tiempo de ejecución de tareas pesadas, como el cálculo de la serie de Fibonacci para grandes números, sino que también garantiza que los recursos del sistema se usen de manera eficiente.

Con esta implementación, aumentamos nuestra capacidad de procesar tareas concurrentemente, algo vital para aplicaciones que requieren manejar cientos o miles de acciones simultáneamente.

Explorar y utilizar workerpools en Go abre la puerta a automáticamente escalar el procesamiento de tareas y es una manera efectiva de manejar cargas de trabajo masivas. Te animo a que profundices más en este tema y sigas experimentando con lo que Go tiene para ofrecer en programación concurrente. ¡La práctica te permitirá dominar estas herramientas poderosas!

slissto slissto

Hace 5 años

Hola, aunque el orden no importe, no tiene más sentido para la lógica del script que primero hagamos el for loop de agregar los valores de tasks dentro del canal de jobs antes de hacer el for loop de iniciar los workers ?

for _, value := range tasks {
		jobs <- value
	}
	close(jobs)

	for i := 0; i < nWorkers; i++ {
		go Worker(i, jobs, results)
	}

Nestor Escoto

Profesor

Hace 5 años

Hola Slissto, una pregunta muy interesante, en este ejemplo en específico podemos alterar ese orden porque estamos usando un channel con el buffer exactamente igual a la longitud de tareas, pero ahora quiero que te imagines un caso donde no sabes con cuantas tareas vas a contar o que por algún motivo supere el tamaño del buffer del canal que estás usando, si implementaramos primero que el channel envía los valores de las tasks lo que ocurrirá muy probablemente es un deadlock porque recuerda que si llegamos a la capacidad máxima del buffer de un channel, tiene que haber algo que esté leyendo de allí para evitar ese bloqueo que te he mencionado.


// Tenemos 20 tareas que ejecutar
tasks := []int{Slice Con 20 elementos}

// Pero creamos un canal con la capacidad de la mitad de las tareas, es decir 10
jobs := make(chan int, len(tasks) /2)
...
...
 for _, value := range tasks { //Esto va a tener 20 iteraciones, pero nuestro channel solo tiene capacidad para 10
		jobs <- value // Cuando vaya por la iteración 11 va a haber problemas porque el channel está lleno y no hay nadie quien esté leyendo y procesando las tasks
	}
  for i := 0; i < nWorkers; i++ {
		go Worker(i, jobs, results) // Por más seguridad es mejor poner esto de primero.
	}

Comentarios (15)15 comentarios

Arnold Kevin Guzman Campos

Sebastian CA

Luis Gonzalez

Omar Lozano

Hace 4 años

Ivan Yerry Hinojosa Zegarra

Gerson Daniel Gutierrez Acosta

Jorge Miguel Anaya León

Wilmer David Cedeño Mendoza

Luis Rosales

Jesus Eduardo Murrieta Rosas

Carlos Nassif Trejo Garcia

Oscar Giraldo Castillo

Hace 9 meses

Carlos Ayala

Leonardo Valdivieso

Hace 3 años

Juan Fernando Sánchez Suarez

Hace 2 años

Eduardo Rodriguez Cisneros

Ajitzi Ricardo Quintana Ruiz

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

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