Los canales se pueden definir como conductos mediante los cuales se comunican Goroutines . Al igual que el agua fluye de un extremo a otro en una tubería, los datos se pueden enviar desde un extremo y recibir desde el otro mediante canales. Por defecto, los canales no tienen búfer, lo que indica que solo aceptarán envíos (chan <-) si hay una recepción correspondiente (<- chan) que esté lista para recibir el valor enviado. Los canales almacenados permiten aceptar un número limitado de valores sin un receptor correspondiente para esos valores. Es posible crear un canal con un buff. Los canales con búfer se bloquean solo cuando el búfer está lleno. Del mismo modo, la recepción de un canal con búfer se bloquea solo cuando el búfer estará vacío.
Los canales con búfer se pueden crear pasando un parámetro de capacidad adicional a la función make() que especifica el tamaño del búfer.
Sintaxis:
ch := make(tipo de chan, capacidad)
Aquí, la capacidad en la sintaxis anterior debe ser mayor que 0 para que un canal tenga un búfer. La capacidad de un canal sin búfer es 0 de forma predeterminada y, por lo tanto, omite el parámetro de capacidad.
Ejemplo 1: código para crear un canal con búfer.
Go
package main
import (
"fmt"
)
func main() {
// create a buffered channel
// with a capacity of 2.
ch := make(chan string, 2)
ch <- "geeksforgeeks"
ch <- "geeksforgeeks world"
fmt.Println(<-ch)
fmt.Println(<-ch)
}
Producción:
geeksforgeeks geeksforgeeks world
Aquí, en el código anterior, es posible escribir 2 strings en el canal sin bloquearse. Lleva 2 strings al canal y no bloquea e imprime el resultado.
Ejemplo 2: programa que escribe en el bloque de canales almacenados en búfer.
Go
package main
import (
"fmt"
"time"
)
func write(ch chan int) {
for i := 0; i < 4; i++ {
ch <- i
fmt.Println("successfully wrote", i, "to ch")
}
close(ch)
}
func main() {
// creates capacity of 2
ch := make(chan int, 2)
go write(ch)
time.Sleep(2 * time.Second)
for v := range ch {
fmt.Println("read value", v, "from ch")
time.Sleep(2 * time.Second)
}
}
Producción:
successfully wrote 0 to ch successfully wrote 1 to ch read value 0 from ch successfully wrote 2 to ch read value 1 from ch successfully wrote 3 to ch read value 2 from ch read value 3 from ch
Aquí, en el código anterior, el Goroutine de escritura tiene un bucle for que escribe números del 0 al 3 en el canal ch. La capacidad de este canal almacenado en búfer es 2 y, por lo tanto, la Goroutine de escritura podrá escribir los valores 0 y 1 en el canal ch inmediatamente y luego se bloqueará hasta que se lea al menos un valor del canal ch como se define a continuación:
successfully wrote 0 to ch successfully wrote 1 to ch
Después de eso, el valor de lectura y luego vuelve a dormir durante 2 segundos y este ciclo continúa hasta que se cierra el canal. Entonces el programa imprimirá las siguientes líneas después de 2 segundos, como:
read value 0 from ch successfully wrote 2 to ch
Y esto continuará hasta que todos los valores se escriban en el canal y se cierre en el Goroutine de escritura .
Se define como una situación en la que el programa durante la ejecución dará como resultado un error fatal debido a pánico en tiempo de ejecución.
Ejemplo :
Go
package main
import (
"fmt"
)
func main() {
ch := make(chan string, 2)
ch <- "geeksforgeeks"
ch <- "hello"
ch <- "geeks"
fmt.Println(<-ch)
fmt.Println(<-ch)
}
Aquí, en el código anterior, la escritura está bloqueada ya que el canal ha excedido su capacidad y el programa llega a una situación de interbloqueo e imprime el siguiente mensaje:
Publicación traducida automáticamente
Artículo escrito por kaurbal1698 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA