Channels in Go are a powerful feature used for communication between goroutines. They allow you to send and receive values, making it easy to synchronize data between concurrently running functions. Channels help to ensure that data is safely shared between goroutines and avoid race conditions.

Unbuffered Channels

• Making a new channel

ch := make(chan int)

• Call a new goroutine

go func(){
	ch <- 4
}()

• Receive the value from the channel in the main thread

value := <- ch

• Print the value

package main

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

	go func() {
		ch <- 5
	}()

	value := <-ch
	println(value)
}

By default sends and receives block until both the sender and receiver are ready

<aside> 💡

• An unbuffered channel does not have any capacity to hold data; it only allows sending and receiving data to occur simultaneously.
• If a goroutine sends data to an unbuffered channel, it will block until another goroutine receives that data. </aside>

Channel Buffering

• A buffered channel has a specified capacity. It allows sending multiple values to the channel before it blocks.
• Sending to a buffered channel only blocks when the buffer is full, and receiving blocks when the buffer is empty.

package main

import (
	"fmt"
	"time"
)

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

	go func() {
		for i := range 10 {
			fmt.Println("sent data ", i)
			ch <- i
		}
	}()

	time.Sleep(time.Second * 5)
	println(<-ch)
}

Looping over channels using range

You can also loop over channels

package main

import (
	"fmt"
	"time"
)

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

	go func() {
		for i := range 10 {
			fmt.Println("sent data ", i)
			ch <- i
		}
	}()

	time.Sleep(time.Second * 5)
	for value := range ch {
		println(value)
	}
}