2. Channels

Channels are a typed, thread-safe queue. Channels allow different goroutines to communicate with each other.

Create a Channel

Like maps and slices, channels must be created before use. They also use the same make keyword:

ch := make(chan int)

Examples:

ch := make(chan int)           // Channel of integers
msgCh := make(chan string)     // Channel of strings
userCh := make(chan user)      // Channel of user structs

Send Data to a Channel

ch <- 69

The <- operator is called the channel operator. Data flows in the direction of the arrow. This operation will block until another goroutine is ready to receive the value.

Receive Data from a Channel

v := <-ch

This reads and removes a value from the channel and saves it into the variable v. This operation will block until there is a value in the channel to be read.

Reference Type

Like maps and slices, channels are reference types, meaning they are passed by reference by default.

func send(ch chan int) {
    ch <- 99
}

func main() {
    ch := make(chan int)
    go send(ch)
    fmt.Println(<-ch) // 99
}

No need for pointers.

Blocking and Deadlocks

A deadlock is when a group of goroutines are all blocking so none of them can continue. This is a common bug that you need to watch out for in concurrent programming.

What channels are, conceptually:

• One goroutine puts data in one end

• Another goroutine takes data out the other end

Channel Operator: <-

The arrow shows the direction of data flow.

Send to channel:

ch <- 69

• Data flows into the channel

• Reads as: "send 69 into ch"

Receive from channel:

v := <-ch

• Data flows out of the channel

• Reads as: "receive from ch into v"

Complete Example

package main

import "fmt"

func main() {
    ch := make(chan int)
    
    // Send in a goroutine
    go func() {
        ch <- 42  // Send 42 into channel
    }()
    
    // Receive in main
    value := <-ch  // Receive from channel
    fmt.Println(value)  // 42
}

Blocking Behavior

Channels block until the other side is ready.

Send blocks:

ch <- 99  // Blocks until someone receives

Receive blocks:

v := <-ch  // Blocks until someone sends

Example: Communication Between Goroutines

func sendData(ch chan string) {
    ch <- "Hello from goroutine"
}

func main() {
    ch := make(chan string)
    
    go sendData(ch)  // Start goroutine
    
    msg := <-ch  // Wait for and receive message
    fmt.Println(msg)  // "Hello from goroutine"
}

Flow:

1

Create channel

2

Start goroutine that will send

3

Main waits to receive

4

Goroutine sends, main receives

5

Both continue

Multiple Sends and Receives

func worker(ch chan int) {
    ch <- 1
    ch <- 2
    ch <- 3
}

func main() {
    ch := make(chan int)
    go worker(ch)
    
    fmt.Println(<-ch)  // 1
    fmt.Println(<-ch)  // 2
    fmt.Println(<-ch)  // 3
}

Deadlock Example

This will deadlock:

func main() {
    ch := make(chan int)
    ch <- 42  // ❌ DEADLOCK! No one to receive
    fmt.Println(<-ch)
}

Why:

• ch <- 42 blocks waiting for a receiver

• But there's no goroutine to receive

• Program freezes forever

Error:

fatal error: all goroutines are asleep - deadlock!

Fixing the Deadlock

Solution: use a goroutine

func main() {
    ch := make(chan int)
    
    go func() {
        ch <- 42  // Send in goroutine
    }()
    
    fmt.Println(<-ch)  // Receive in main
}

Now it works because:

• Goroutine sends

• Main receives

• They coordinate through the channel

Real-World Example: Sending Results

func calculateSquare(n int, result chan int) {
    result <- n * n
}

func main() {
    result := make(chan int)
    
    go calculateSquare(5, result)
    go calculateSquare(10, result)
    
    fmt.Println(<-result)  // 25 or 100
    fmt.Println(<-result)  // 100 or 25
}

Channel Direction Arrows

Visual guide:

ch <- 42      // Send: arrow points INTO channel
              //       42 ─→ ch

v := <-ch     // Receive: arrow points OUT OF channel
              //          ch ─→ v

Common Patterns

Pattern: Send and close

func sender(ch chan int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch)  // Signal we're done
}

Pattern: Receive until closed

func receiver(ch chan int) {
    for v := range ch {  // Receive until closed
        fmt.Println(v)
    }
}

Pattern: Multiple workers

func main() {
    ch := make(chan int)
    
    go worker(ch)
    go worker(ch)
    go worker(ch)
    
    for i := 0; i < 10; i++ {
        ch <- i  // Workers compete for tasks
    }
}

Key Takeaways

1

Create: ch := make(chan Type)

2

Send: ch <- value (blocks until received)

3

Receive: value := <-ch (blocks until sent)

4

Reference type: Pass by reference automatically

5

Watch for deadlocks: Always have sender and receiver

Quick Reference

Operation	Syntax	Blocks Until
Create	ch := make(chan int)	N/A
Send	ch <- 42	Someone receives
Receive	v := <-ch	Someone sends
Close	close(ch)	N/A

Remember: The arrow <- shows data flow direction!

Assignment

Run the program. You'll see that it deadlocks and never exits. The sendIsOld function is trying to send on a channel, but no other goroutines are running that can accept the value from the channel.

Fix the deadlock by spawning a goroutine to send the "is old" values.

Original code:

package main

import (
	"time"
)

type email struct {
	body string
	date time.Time
}

func checkEmailAge(emails [3]email) [3]bool {
	isOldChan := make(chan bool)

	sendIsOld(isOldChan, emails)

	isOld := [3]bool{}
	isOld[0] = <-isOldChan
	isOld[1] = <-isOldChan
	isOld[2] = <-isOldChan
	return isOld
}

// don't touch below this line

func sendIsOld(isOldChan chan<- bool, emails [3]email) {
	for _, e := range emails {
		if e.date.Before(time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC)) {
			isOldChan <- true
			continue
		}
		isOldChan <- false
	}
}

Solution (spawn the sender as a goroutine):

package main

import (
	"time"
)

type email struct {
	body string
	date time.Time
}

func checkEmailAge(emails [3]email) [3]bool {
	isOldChan := make(chan bool)

	go sendIsOld(isOldChan, emails)

	isOld := [3]bool{}
	isOld[0] = <-isOldChan
	isOld[1] = <-isOldChan
	isOld[2] = <-isOldChan
	return isOld
}

// don't touch below this line

func sendIsOld(isOldChan chan<- bool, emails [3]email) {
	for _, e := range emails {
		if e.date.Before(time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC)) {
			isOldChan <- true
			continue
		}
		isOldChan <- false
	}
}