DS & II

Capítulo 07 - O Walkie-Talkie

Leitura de 4 min

🚀 Capítulo 07: O Walkie-Talkie de Stranger Things (Tema: Stranger Things)

NOTE

Este capítulo utiliza a temática de Stranger Things para explicar os Channels (Canais) em Go. Aprenda a fazer as suas Goroutines conversarem de forma segura!

1. 🎯 Objetivo da Aula

Compreender o conceito de Channels (Canais) em Go, como eles permitem a comunicação e sincronização segura de dados entre diferentes Goroutines.

2. 🏢 O Cenário Prático (Seu Desafio)

Na série Stranger Things, as crianças de Hawkins usam seus famosos Walkie-Talkies para se comunicarem. Quando o Dustin quer falar com o Lucas, ele aperta o botão e fala. O Lucas precisa estar sintonizado no mesmo canal de rádio para escutar a mensagem. Se o Dustin falar e ninguém estiver escutando do outro lado, a mensagem fica “travada” no ar até que alguém escute!

No capítulo anterior, nós aprendemos a criar clones (Goroutines) para trabalhar em segundo plano. Mas como esses clones conversam entre si para trocar informações sem dar bagunça na memória?

  • Nós usamos os Channels (Canais)!
  • Um canal em Go funciona exatamente como um Walkie-Talkie: uma Goroutine envia um dado por ele, e outra Goroutine do outro lado recebe esse dado. Seu desafio é sintonizar o canal!

🧠 Fundamentos: A Teoria Traduzida

Os canais são as “tubulações” por onde os dados fluem entre as goroutines. Eles garantem que apenas uma goroutine mexa naquele dado por vez, evitando erros bizarros de memória!

📻 1. Criando um Canal:

Usamos a função make e dizemos qual tipo de dado vai passar por aquele canal (ex: só passa strings).

canalMensagens := make(chan string)

📤 2. Enviando Dados (<- seta para a esquerda):

A seta aponta para dentro do canal! Significa que estamos jogando a informação lá dentro.

canalMensagens <- "O Demogorgon está vindo!"

📥 3. Recebendo Dados (<- seta antes do canal):

A seta puxa a informação para fora do canal e guarda em uma variável!

mensagemRecebida := <-canalMensagens

4. 📖 Exemplo Guiado: O Chamado do Dustin

Vamos simular o Dustin enviando uma mensagem via rádio para o Lucas:

package main
 
import "fmt"
 
func enviarMensagem(radio chan string) {
    radio <- "Código Vermelho! Câmbio." // Envia a mensagem
}
 
func main() {
    // Cria o walkie-talkie (canal)
    radio := make(chan string)
 
    // Dustin vai para o quarto enviar a mensagem (Goroutine)
    go enviarMensagem(radio)
 
    // Lucas fica na cozinha esperando o rádio chiar
    mensagem := <-radio // Trava o código aqui até a mensagem chegar!
 
    fmt.Println("Lucas recebeu no rádio:", mensagem)
}

5. 🛠️ Prática Obrigatória 1: Operações no Canal

Imagine que você tem um canal de números inteiros criado assim: canalNumeros := make(chan int).

  1. Como você envia o número para dentro desse canal?
  2. Como você recebe o número que está dentro desse canal e o guarda em uma variável chamada resultado?

6. 🛠️ Prática Obrigatória 2: O Bloqueio

  1. Os canais em Go possuem uma característica chamada “Bloqueante” (Blocking). O que acontece com a função main quando ela executa a linha mensagem := <-radio e ainda não tem nenhuma mensagem dentro do canal para ser lida? O programa continua rodando ou ele para e espera?

7. 📤 Instruções de Entrega (GitHub Desktop + Microsoft Teams)

  1. Faça o Commit: No GitHub Desktop, digite a mensagem (ex: Finaliza Capítulo 07 Go_StrangerThings) e clique em Commit to main.
  2. Envie para a Nuvem (Push): Clique em Push origin.

8. 📂 Estrutura de Pastas

spec_backend_com_golang_e_gin/
├── capitulos/
│   └── capitulo_07_stranger_things.md

💡 Checkpoint de Lógica

Em Go existe a filosofia: “Não comunique compartilhando memória; em vez disso, compartilhe memória se comunicando!“. Os canais são a aplicação prática dessa filosofia!

10. 🔥 Desafio de Fixação

Pesquise o que são Buffered Channels (Canais com Buffer) em Go e qual a diferença deles para os canais normais que vimos aqui (Dica: tem a ver com poder enviar mensagens mesmo sem ninguém escutando do outro lado!).

🔑 Gabarito de Código/Fórmulas

Gabarito da Prática 1:

  1. canalNumeros <- 42
  2. resultado := <-canalNumeros Gabarito da Prática 2:
  3. Ele para e espera! O programa fica pausado exatamente naquela linha de código até que outra Goroutine envie algum dado para dentro do canal. Isso é ótimo porque evita que o computador fique gastando processamento à toa enquanto espera!

← Capitulo Anterior | Proximo Capitulo →

Visão de gráfico

Backlinks