Channel in Golang

Channels are a fundamental feature of concurrent programming in Go, providing a safe and structured way to communicate and synchronize between goroutines. Channels allow you to send and receive data between goroutines, ensuring that the data exchange happens in a synchronized and coordinated manner.

Here’s a breakdown of key points about channels in Go:

  1. Creating Channels:
    • Channels are created using the make function: ch := make(chan Type).
    • Channels can be unbuffered (synchronous) or buffered (asynchronous). Unbuffered channels block until both sender and receiver are ready. Buffered channels allow a specific number of values to be stored without blocking.
  2. Sending and Receiving:
    • Use the <- operator to send data into a channel: ch <- data.
    • Use the <- operator to receive data from a channel: data := <-ch.
  3. Blocking Behavior:
    • Sending blocks if the channel is full (for unbuffered channels) or if the buffer is full (for buffered channels).
    • Receiving blocks if the channel is empty (for unbuffered channels) or if the buffer is empty (for buffered channels).
  4. Close a Channel:
    • A sender can close a channel using the close(ch) function.
    • Receiving from a closed channel yields the remaining values and then returns zero value and a boolean indicating closed status.
  5. Select Statement:
    • The select statement is often used with channels to handle multiple channels concurrently, waiting for the first one that’s ready.
  6. Channel Direction:
    • You can specify whether a channel is used only for sending or only for receiving by using direction syntax: ch := make(chan Type) (bidirectional), ch := make(chan<- Type) (send-only), ch := make(<-chan Type) (receive-only).

Here’s a simple example illustrating the usage of channels:

package main

import (

func main() {
	ch := make(chan int) // Create an unbuffered channel

	go func() {
		for i := 1; i <= 5; i++ {
			ch <- i // Send data into the channel
			time.Sleep(time.Millisecond * 500)
		close(ch) // Close the channel when done sending

	// Receive data from the channel
	for num := range ch {
		fmt.Printf("Received: %d\n", num)

	fmt.Println("Channel is closed")

Output :

Received: 1
Received: 2
Received: 3
Received: 4
Received: 5
Channel is closed

In this example, a goroutine sends data into the channel, and the main goroutine receives the data. The range loop is used to iterate over the channel until it’s closed.

Channels provide a powerful and safe way to coordinate communication between goroutines, making it easier to build concurrent programs without the risk of race conditions.