Introduction

In Go, channels are a fundamental construct for enabling communication and synchronization between goroutines (concurrently executing functions). By default, channels in Go are unbuffered, meaning they can only hold one value at a time. Buffered channels, on the other hand, have a capacity and can hold multiple values.

This tutorial will provide an in-depth understanding of buffered channels in Go. By the end of this tutorial, you will be able to create buffered channels, send and receive values through them, and understand the differences between buffered and unbuffered channels.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Go programming language syntax and concepts. It would be helpful to be familiar with goroutines and channels in Go.

Setting up Go

Before we begin working with buffered channels, make sure you have Go installed on your system. You can download and install Go from the official Go website (https://golang.org/dl/). Follow the installation instructions specific to your operating system.

Once Go is installed, open a terminal or command prompt and verify your installation by running the following command:

go version

If you see the version number printed, you have successfully installed Go.

Understanding Channels

Channels in Go provide a way for goroutines to communicate and synchronize their execution. A channel can be thought of as a conduit through which values can flow. One goroutine can send a value into a channel, and another goroutine can receive that value from the same channel.

Channels can be created using the built-in make function, and they come in two flavors: unbuffered and buffered.

Buffered Channels

A buffered channel in Go has a capacity that determines how many values it can hold. When a goroutine sends a value to a buffered channel, it gets added to the channel’s internal buffer if there is space available. If the channel is already full, the sending goroutine will block until space becomes available.

Similarly, when a goroutine tries to receive a value from a buffered channel, it will receive a value from the buffer if there is one available. If the buffer is empty, the receiving goroutine will block until a value is sent to the channel.

The capacity of a buffered channel can be specified when creating the channel. For example, a buffered channel with a capacity of 3 can hold up to 3 values before sending goroutines block.

Creating Buffered Channels

To create a buffered channel in Go, we use the make function and specify the capacity as the second argument. Let’s create a buffered channel with a capacity of 3:

bufferedChannel := make(chan int, 3)

In the above code, we create a buffered channel bufferedChannel capable of holding 3 integer values.

Sending and Receiving Values

Sending and receiving values through buffered channels follow the same syntax as unbuffered channels. Here’s an example that demonstrates sending and receiving values through a buffered channel:

package main

import "fmt"

func main() {
    bufferedChannel := make(chan string, 2)
    
    bufferedChannel <- "Hello"
    bufferedChannel <- "World"
    
    fmt.Println(<-bufferedChannel)
    fmt.Println(<-bufferedChannel)
}

In the above code, we create a buffered channel bufferedChannel with a capacity of 2. We then send two strings into the channel using the <- operator. Finally, we receive and print the values from the channel using the <- operator and the fmt.Println function.

The output of the above code will be:

Hello
World

Closing Buffered Channels

In Go, it is a best practice to always close a channel after you are done sending values through it. Closing a channel indicates to the receiving goroutines that no more values will be sent. It also allows the receiving goroutines to detect when all the values have been received.

To close a buffered channel, we use the built-in close function. Here’s an example that demonstrates closing a buffered channel:

package main

import "fmt"

func main() {
    bufferedChannel := make(chan int, 3)
    
    bufferedChannel <- 1
    bufferedChannel <- 2
    bufferedChannel <- 3
    
    close(bufferedChannel)
    
    for value := range bufferedChannel {
        fmt.Println(value)
    }
}

In the above code, we create a buffered channel bufferedChannel and send three integer values into it. After sending the values, we close the channel using the close function. We then use a for loop with the range form to receive and print all the values from the channel.

The output of the above code will be:

1
2
3

Buffered Channels vs Unbuffered Channels

Buffered channels and unbuffered channels have some key differences:

Unbuffered channels are synchronous, meaning a send operation and a receive operation on an unbuffered channel must both be ready to proceed for the communication to happen. Buffered channels, on the other hand, allow asynchronous communication. A send operation on a buffered channel can proceed as long as there is space available in the buffer, even if there is no receiver yet. Similarly, a receive operation on a buffered channel can proceed as long as there is a value available in the buffer, even if there is no sender yet.
Buffered channels have a capacity and can hold multiple values. Unbuffered channels can only hold one value at a time.
Sending a value to a buffered channel will only block if the buffer is already full. Sending a value to an unbuffered channel will always block until there is a receiver ready to receive the value.
Receiving a value from a buffered channel will only block if the buffer is empty. Receiving a value from an unbuffered channel will always block until there is a sender ready to send the value.

Choose between buffered and unbuffered channels based on your specific use case and the desired behavior of your program.

Conclusion

In this tutorial, we covered buffered channels in Go. We learned how to create buffered channels with a specific capacity, send and receive values through buffered channels, and close buffered channels. We also discussed the differences between buffered and unbuffered channels.

Buffered channels provide a powerful tool for concurrent programming in Go by allowing asynchronous communication and buffering of values. Understanding how to use buffered channels effectively can greatly enhance the performance and flexibility of your Go programs.

Now that you have a good understanding of buffered channels, you can start using them in your own Go projects. Explore the Go standard library and discover the many ways you can leverage buffered channels for concurrent programming tasks.

Happy coding!

Published: 30 December 2021

Buffered Channels in Go: An In-depth Tutorial

Table of Contents