El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Goroutines

Siguiente ►
►

Las goroutines son una característica fundamental de Go que permite la concurrencia de manera eficiente y sencilla. En este tema, aprenderás qué son las goroutines, cómo utilizarlas y cómo manejarlas adecuadamente.

¿Qué es una Goroutine?

Una goroutine es una función que se ejecuta de manera concurrente con otras goroutines en el mismo espacio de direcciones. Las goroutines son ligeras y gestionadas por el runtime de Go, lo que las hace más eficientes en términos de memoria y rendimiento en comparación con los hilos del sistema operativo.

Características de las Goroutines

  • Ligereza: Las goroutines son mucho más ligeras que los hilos del sistema operativo.
  • Gestión Automática: El runtime de Go gestiona la creación y destrucción de goroutines.
  • Concurrencia: Permiten la ejecución concurrente de funciones, mejorando el rendimiento de las aplicaciones.

Sintaxis Básica

Para iniciar una goroutine, simplemente anteponemos la palabra clave go a la llamada de una función.

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    fmt.Println("Hello, World!")
}

func main() {
    go sayHello() // Inicia una goroutine
    time.Sleep(1 * time.Second) // Espera para que la goroutine termine
}

Explicación del Código

  1. Definición de la Función: La función sayHello imprime "Hello, World!".
  2. Iniciar la Goroutine: En main, la función sayHello se llama con la palabra clave go, iniciando una goroutine.
  3. Esperar la Finalización: time.Sleep(1 * time.Second) se usa para dar tiempo a la goroutine para que termine su ejecución antes de que el programa principal finalice.

Ejemplo Práctico

Vamos a crear un ejemplo más complejo donde varias goroutines se ejecutan simultáneamente.

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
        time.Sleep(500 * time.Millisecond)
    }
}

func printLetters() {
    for i := 'A'; i <= 'E'; i++ {
        fmt.Printf("%c\n", i)
        time.Sleep(700 * time.Millisecond)
    }
}

func main() {
    go printNumbers()
    go printLetters()
    time.Sleep(4 * time.Second) // Espera para que ambas goroutines terminen
}

Explicación del Código

  1. Funciones Concurrentes: printNumbers imprime números del 1 al 5, y printLetters imprime letras de la A a la E.
  2. Iniciar Goroutines: Ambas funciones se inician como goroutines en main.
  3. Sincronización: time.Sleep(4 * time.Second) asegura que el programa principal espere lo suficiente para que ambas goroutines terminen.

Ejercicio Práctico

Ejercicio 1: Contador Concurrente

Escribe un programa que inicie dos goroutines. Una goroutine debe contar de 1 a 5 y la otra debe contar de 6 a 10. Ambas deben imprimir sus números con un retraso de 1 segundo entre cada número.

Solución

package main

import (
    "fmt"
    "time"
)

func count(start, end int) {
    for i := start; i <= end; i++ {
        fmt.Println(i)
        time.Sleep(1 * time.Second)
    }
}

func main() {
    go count(1, 5)
    go count(6, 10)
    time.Sleep(6 * time.Second) // Espera para que ambas goroutines terminen
}

Retroalimentación y Consejos

  • Error Común: No esperar lo suficiente para que las goroutines terminen. Usa time.Sleep o canales para sincronizar.
  • Consejo: Usa canales para una mejor sincronización y comunicación entre goroutines, lo cual aprenderemos en el siguiente tema.

Conclusión

En este tema, hemos aprendido qué son las goroutines, cómo iniciarlas y cómo manejarlas adecuadamente. Las goroutines son una herramienta poderosa para la concurrencia en Go, permitiendo la ejecución eficiente de múltiples tareas simultáneamente. En el próximo tema, exploraremos los canales, que son esenciales para la comunicación y sincronización entre goroutines.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados