Channels

Channels in Go are a powerful mechanism for communication between goroutines, allowing them to share data safely and synchronize execution. Channels provide a way to send and receive values between goroutines, ensuring that communication is both type-safe and synchronized.

What Are Channels?

A channel in Go acts as a conduit for passing data between goroutines. They are created using the make function and have a specific type that defines the type of data they can transport.

Types of Channels:

Unbuffered Channels: Require both sender and receiver to be ready at the same time.
Buffered Channels: Allow a limited number of values to be stored without requiring immediate synchronization.

Creating Channels

ch := make(chan int) // Create an unbuffered channel of type int

To create a buffered channel:

ch := make(chan int, 3) // Create a buffered channel with capacity of 3

Basic Channel Operations

1. Sending Data

To send data to a channel, use the ch <- value syntax.

ch <- 42 // Send value 42 to channel ch

2. Receiving Data

To receive data from a channel, use the value := <-ch syntax.

value := <-ch // Receive a value from channel ch

Examples

Example 1: Unbuffered Channel

In an unbuffered channel, the sender waits until the receiver is ready to accept the data, and vice versa.

package main

import (
	"fmt"
)

func sendData(ch chan int) {
	ch <- 10 // Send data
}

func main() {
	ch := make(chan int)

	go sendData(ch) // Start goroutine

	data := <-ch // Receive data
	fmt.Println("Received:", data)
}

Output:

Received: 10

Example 2: Buffered Channel

Buffered channels allow the sender to send multiple values without an immediate receiver.

package main

import (
	"fmt"
)

func main() {
	ch := make(chan int, 2) // Buffered channel with capacity 2

	ch <- 1
	ch <- 2

	fmt.Println(<-ch) // Output: 1
	fmt.Println(<-ch) // Output: 2
}

If the channel buffer is full, the sender blocks until space becomes available.

Example 3: Goroutines with Channels

package main

import (
	"fmt"
)

func produce(ch chan int) {
	for i := 0; i < 5; i++ {
		ch <- i
	}
	close(ch) // Close the channel
}

func main() {
	ch := make(chan int)

	go produce(ch)

	for val := range ch { // Receive values until the channel is closed
		fmt.Println(val)
	}
}

Output:

Direction-Specific Channels

Channels can be restricted to send-only or receive-only to improve clarity and safety.

Example: Send-Only and Receive-Only Channels

package main

import "fmt"

func sendOnly(ch chan<- int) {
	ch <- 42 // Send value
}

func receiveOnly(ch <-chan int) {
	fmt.Println(<-ch) // Receive value
}

func main() {
	ch := make(chan int)

	go sendOnly(ch)
	receiveOnly(ch)
}

Output:

Channel Synchronization

Channels can synchronize execution between goroutines.

package main

import (
	"fmt"
)

func worker(done chan bool) {
	fmt.Println("Working...")
	done <- true // Signal that work is done
}

func main() {
	done := make(chan bool)

	go worker(done)

	<-done // Wait for signal
	fmt.Println("Work completed")
}

Output:

Working...
Work completed

Select Statement

The select statement allows a goroutine to wait on multiple channel operations.

Example: Multiple Channel Operations

package main

import (
	"fmt"
)

func main() {
	ch1 := make(chan string)
	ch2 := make(chan string)

	go func() {
		ch1 <- "Hello from ch1"
	}()

	go func() {
		ch2 <- "Hello from ch2"
	}()

	select {
	case msg1 := <-ch1:
		fmt.Println(msg1)
	case msg2 := <-ch2:
		fmt.Println(msg2)
	}
}

The expected output is either "Hello from ch1" or "Hello from ch2". The select statement chooses the first channel that is ready to communicate.

But why isn't the output deterministic? Because the goroutines are running concurrently, and the select statement picks the first channel that is ready to communicate.

If both channels are ready, the select statement randomly chooses one of them.

If you expect both messages to be received, you can use a loop to receive from both channels.

Closing a Channel

Channels can be closed using the close function. A closed channel cannot receive new values, but it can still be read until it's empty.

Example: Closing a Channel

package main

import (
	"fmt"
)

func main() {
	ch := make(chan int, 3)

	ch <- 1
	ch <- 2

	close(ch)

	for val := range ch {
		fmt.Println(val)
	}
}

Output:

1
2

Best Practices

Avoid Sending on Closed Channels: Sending to a closed channel causes a panic.
Use ok Idiom: To check if a channel is closed during a read.
value, ok := <-ch if !ok { fmt.Println("Channel is closed") }
Limit Channel Buffer Sizes: Use buffered channels carefully to avoid deadlocks or memory issues.
Always Close Channels Gracefully: Close channels only when no other goroutine will send to them.

By leveraging channels effectively, Go programmers can build robust concurrent systems with safe and clear communication between goroutines.

Last modified: 29 December 2024