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

Canales

Siguiente ►
►

Los canales en Go son una poderosa característica que permite la comunicación segura entre goroutines. Los canales proporcionan una forma de enviar y recibir valores entre goroutines, lo que facilita la sincronización y la coordinación de tareas concurrentes.

Conceptos Clave

  1. Definición de Canales: Un canal es un tipo de dato que permite enviar y recibir valores de un tipo específico entre goroutines.
  2. Creación de Canales: Los canales se crean utilizando la función make.
  3. Operaciones Básicas: Las operaciones principales con canales son el envío (<-) y la recepción (<-).
  4. Canales Bufferizados y No Bufferizados: Los canales pueden ser bufferizados (con capacidad) o no bufferizados (sin capacidad).

Creación de Canales

Para crear un canal, se utiliza la función make con la sintaxis:

ch := make(chan int) // Canal no bufferizado de enteros

Para crear un canal bufferizado, se especifica la capacidad del buffer:

ch := make(chan int, 5) // Canal bufferizado con capacidad de 5 enteros

Envío y Recepción de Datos

Envío de Datos

Para enviar un valor a un canal, se utiliza el operador <-:

ch <- 42 // Envía el valor 42 al canal ch

Recepción de Datos

Para recibir un valor de un canal, también se utiliza el operador <-:

value := <-ch // Recibe un valor del canal ch y lo asigna a la variable value

Ejemplo Práctico

A continuación, se muestra un ejemplo práctico que ilustra el uso de canales para comunicar dos goroutines:

package main

import (
    "fmt"
    "time"
)

func main() {
    // Crear un canal no bufferizado
    ch := make(chan string)

    // Iniciar una goroutine que envía un mensaje a través del canal
    go func() {
        time.Sleep(2 * time.Second)
        ch <- "Hola desde la goroutine"
    }()

    // Recibir el mensaje desde el canal
    msg := <-ch
    fmt.Println(msg)
}

Explicación del Código

  1. Creación del Canal: Se crea un canal no bufferizado ch de tipo string.
  2. Goroutine: Se inicia una goroutine que espera 2 segundos y luego envía un mensaje al canal ch.
  3. Recepción del Mensaje: La goroutine principal espera a recibir el mensaje del canal ch y luego lo imprime.

Canales Bufferizados

Los canales bufferizados permiten almacenar múltiples valores en el canal sin necesidad de que una goroutine receptora esté lista para recibirlos inmediatamente.

Ejemplo de Canal Bufferizado

package main

import (
    "fmt"
)

func main() {
    // Crear un canal bufferizado con capacidad de 2
    ch := make(chan int, 2)

    // Enviar dos valores al canal
    ch <- 1
    ch <- 2

    // Recibir los valores del canal
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

Explicación del Código

  1. Creación del Canal Bufferizado: Se crea un canal bufferizado ch con capacidad de 2.
  2. Envío de Valores: Se envían dos valores al canal.
  3. Recepción de Valores: Se reciben y se imprimen los dos valores del canal.

Ejercicios Prácticos

Ejercicio 1: Comunicación Básica

Descripción: Crea un programa que inicie dos goroutines. Una goroutine debe enviar un mensaje a través de un canal, y la otra goroutine debe recibir y mostrar el mensaje.

Solución:

package main

import (
    "fmt"
)

func main() {
    ch := make(chan string)

    go func() {
        ch <- "Mensaje desde la primera goroutine"
    }()

    go func() {
        msg := <-ch
        fmt.Println(msg)
    }()

    // Esperar para que las goroutines terminen
    var input string
    fmt.Scanln(&input)
}

Ejercicio 2: Canal Bufferizado

Descripción: Crea un programa que utilice un canal bufferizado para enviar y recibir tres valores enteros.

Solución:

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int, 3)

    ch <- 10
    ch <- 20
    ch <- 30

    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

Resumen

En esta sección, hemos aprendido sobre los canales en Go, cómo crearlos, y cómo utilizarlos para enviar y recibir datos entre goroutines. También hemos explorado la diferencia entre canales bufferizados y no bufferizados, y hemos visto ejemplos prácticos y ejercicios para reforzar los conceptos aprendidos. En la siguiente sección, profundizaremos en la instrucción select, que permite manejar múltiples operaciones de canal de manera concurrente.

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