Go Concurrency

Go Channels

Send values between goroutines with channels: unbuffered, buffered, close and range.

  • Advanced
  • 3 min read
  • 1 runnable example
What you'll learn
  • Send and receive
  • close and range
  • Buffered channels
Producer to main
  1. 1out <- messageproducer goroutine
  2. 2chan stringstep 1, step 2, step 3
  3. 3range 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

  1. ch <- v sends and <-ch receives.
  2. close ends a range loop.
  3. A buffered channel holds values without a receiver.

Runnable Go example

Go
Run code →
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)
}
Get a Run button for this example Result of running the code
received: step 1 done
received: step 2 done
received: step 3 done
2 1 2

Practice

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.

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