Skip to main content
In this lesson, we explore channels in Go and how they enable seamless communication between goroutines. Channels allow data to flow between different parts of your code, often across multiple goroutines, thereby simplifying concurrent programming by reducing the complexity inherent in traditional thread synchronization.
In Go, it’s recommended to share memory by communicating, rather than communicating by sharing memory. This approach minimizes the need for locks and other synchronization primitives common in languages like Java or C++.

​
Understanding Channels

Traditionally, multithreaded programming involves protecting shared data structures using locks. Threads often compete for these locks, which can lead to complexities and performance bottlenecks. In contrast, Go’s concurrency model leverages goroutines and channels to handle data exchange more elegantly. Instead of managing locks explicitly, developers pass references or copies of data between goroutines using channels—ensuring that only one goroutine interacts with a particular piece of data at any given time.
The image is a slide discussing channels in programming, highlighting a quote by Rob Pike about sharing memory by communicating, and contrasting it with traditional methods like threads and mutexes.
Channels support bidirectional communication by default, meaning that you can both send and receive values on the same channel. This bidirectional capability allows goroutines to synchronize without the need for explicit locks or condition variables.
The image is a slide discussing channels, highlighting that communication is bidirectional by default, allowing sending and receiving from the same channel. It also notes that channels send and receive until the other side is ready.

​
Declaring and Initializing Channels

In Go, each channel is tied to a specific data type (e.g., int, string). The keyword chan is used during declaration. You can declare a channel and initialize it using the make function as demonstrated below: 
var c chan string

c = make(chan string)

​
Channel Operations

Channels in Go offer several built-in operations that simplify the management of concurrent tasks. These operations include sending and receiving values, closing the channel, and checking its capacity or current length.
The image is a slide titled "Channel Operations," listing four operations: sending a value, receiving a value, closing a channel, and querying the buffer of a channel.
Let’s dive into these operations:
  1. To send a value into a channel, use the send operator (<-)
To send a value into a channel, use the send operator (<-). Ensure that the value is assignable to the channel’s declared type.
ch <- v
  1. To receive a value from a channel, position the send operator on the left sid…
To receive a value from a channel, position the send operator on the left side of the assignment. The returned value is stored in the variable.
val := <-ch
  1. When no further values need to be sent on a channel, close it using the built…
When no further values need to be sent on a channel, close it using the built-in close function.
close(ch)
  1. Use the cap function to retrieve the total size of a channel’s buffer
Use the cap function to retrieve the total size of a channel’s buffer.
cap(ch)
  1. The len function returns the number of elements that are currently pending …
The len function returns the number of elements that are currently pending in the channel’s buffer.
len(ch)

​
Conclusion

This lesson introduced the core concepts of channels in Go, covering their declaration, initialization, and key operations such as sending, receiving, closing, and querying. By facilitating communication between goroutines without explicit locks, channels provide an efficient mechanism for writing concurrent software. We look forward to exploring more advanced topics in the upcoming lessons. For more insights on Go and concurrent programming, consider exploring the Go Documentation and other related resources.

Watch Video