Go Concurrency
Go Channels
Send values between goroutines with channels: unbuffered, buffered, close and range.
What you'll learn
- Send and receive
- close and range
- Buffered channels
Producer to main
- 1
out <- messageproducer goroutine - 2
chan stringstep 1, step 2, step 3 - 3
range messagesmain
A pipe between goroutines
A channel is a pipe that carries values from one goroutine to another. Sending and receiving wait for each other, so channels also keep goroutines in step.
out <- value sends and <-channel receives. An unbuffered channel hands each message directly to the receiver. close tells the receiver that nothing more will come, which ends the range loop. A buffered channel holds up to its capacity without a receiver.
Key points
- ch <- v sends and <-ch receives.
- close ends a range loop.
- A buffered channel holds values without a receiver.
Runnable Go example
main.go
package main
import "fmt"
func produce(steps int, out chan<- string) {
for step := 1; step <= steps; step++ {
out <- fmt.Sprintf("step %d done", step)
}
close(out) // tells the receiver there is nothing more
}
func main() {
messages := make(chan string)
go produce(3, messages)
for message := range messages {
fmt.Println("received:", message)
}
buffered := make(chan int, 2)
buffered <- 1
buffered <- 2
fmt.Println(len(buffered), <-buffered, <-buffered)
}
received: step 1 done
received: step 2 done
received: step 3 done
2 1 2Practice
Open the example in the online compiler, change a value or add a line, and predict the output before you run it. Then break the code on purpose and read the compiler's message.
Finished this lesson?
Mark it as learned to track your progress.
Your progress is saved in this browser Sign in to keep it on every device.
Practice with a challenge
Use what this lesson covers to solve a real problem. Each challenge runs in your browser with instant tests and an AI review.
All challenges