Concurrency is a powerful aspect of Go (Golang) that allows developers to execute multiple tasks concurrently, enabling efficient resource utilization and improved performance. In this article, we’ll explore two key concurrency primitives in Go: goroutines and channels.

Understanding Goroutines

Goroutines are lightweight threads managed by the Go runtime. They enable concurrent execution of functions or methods independently of other parts of the program. Goroutines are more lightweight than operating system threads, allowing Go programs to create thousands or even millions of them without significant overhead.

Creating Goroutines

Creating a goroutine is as simple as prefixing a function call with the go keyword. For example:

package main

import (

func sayHello() {
    fmt.Println("Hello from Goroutine!")

func main() {
    // Start a new goroutine
    go sayHello()

    // Print from main goroutine
    fmt.Println("Hello from Main!")

    // Allow time for goroutine to execute


$ go run goroutines.go 
Hello from Main!
Hello from Goroutine!

In this example, sayHello() is executed concurrently as a goroutine, while the main goroutine continues execution.

Goroutine Pitfalls

  • Lack of Synchronization: Goroutines execute independently, so there’s no inherent synchronization between them. Care must be taken to synchronize access to shared resources to prevent race conditions.
  • Resource Management: Creating too many goroutines concurrently can exhaust system resources. It’s essential to limit the number of concurrently executing goroutines or use techniques like a worker pool.

Using WaitGroups to manage goroutines

Using sync.WaitGroup in Go is a powerful way to manage multiple goroutines, ensuring that the program waits for all of them to finish before proceeding further. WaitGroup has be passed to methods as pointer. Here’s how you can use WaitGroups to manage multiple goroutines effectively:

package main

import (

func routineWork(id int, wg *sync.WaitGroup) {
    fmt.Println("routine ", id, " starting")

    // Imitate processing for goroutine

    fmt.Println("routine ", id, " done")

    // Decrement the WaitGroup counter when done
    defer wg.Done()

func main() {
    // Create WaitGroup
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        // Increment the WaitGroup counter

        // Start new routine worker
        go routineWork(i, &wg)

    // Wait for all workers to finish


$ go run goroutines.go
routine  5  starting
routine  1  starting
routine  3  starting
routine  4  starting
routine  2  starting
routine  2  done
routine  1  done
routine  5  done
routine  3  done
routine  4  done

Understanding Channels

Channels in Go are typed conduits that allow goroutines to communicate with each other and synchronize their execution. They provide a safe and efficient way for goroutines to exchange data without the need for explicit locking mechanisms.

Channel Types

There are two main types of channels in Go: unbuffered and buffered channels.

Unbuffered Channels (Synchronous)

  • Unbuffered channels have no capacity to store data.
  • Every send operation on an unbuffered channel blocks until there’s a corresponding receive operation, and vice versa. This will lead to deadlock.
  • This makes unbuffered channels ideal for synchronization between goroutines.

Buffered Channels (Asynchronous)

  • Buffered channels have a fixed capacity to store data.
  • Send operations on a buffered channel block only when the buffer is full. Receive operations block when the buffer is empty.
  • Buffered channels allow for asynchronous communication between goroutines.

Creating Channels

Channels are created using the make() function, specifying the channel type. Here’s how you can create (synchronous) or buffered (asynchronous) channels:

// Unbuffered channel
ch := make(chan int)

// Buffered channel with capacity 10
ch := make(chan int, 10)

Sending and Receiving Values

The <- operator is used to send and receive values through channels. Sending blocks until the receiver is ready, and receiving blocks until a value is available.

// Sending a value to the channel
ch <- value

// Receiving a value from the channel
value := <-ch

Channel Operations

  • Close: Channels can be closed to indicate that no more values will be sent. Receivers can check if a channel is closed using the second return value from a receive operation.
  • Select: The select statement allows for non-blocking communication with multiple channels. It chooses which case to run based on the readiness of the channels.
select {
case value := <-ch1:
    // Handle value received from ch1
case ch2 <- value:
    // Send value to ch2
case <-time.After(time.Second):
    // Timeout after 1 second

Using Unbuffered Channels

Unbuffered channels are often used for synchronization between goroutines, ensuring that they coordinate their execution. Let’s see an example:

package main

import (

func worker(ch chan string) {
    fmt.Println("Worker: Started")

    // Simulate work

    // Send result to channel
    ch <- "Done"

    fmt.Println("Worker: Finished")

func main() {
    // Define unbuffered channel with string data type
    ch := make(chan string)

    fmt.Println("Main: Start worker goroutine")

    // Start worker goroutine
    go worker(ch)

    fmt.Println("Main: Waiting for result...")

    // Wait to receive result from channel
    result := <-ch

    fmt.Println("Main: Received result:", result)



$ go run channel-ub.go
Main: Start worker goroutine
Main: Waiting for result...
Worker: Started
Main: Received result: Done
Worker: Finished

In this example:

  • We create an unbuffered channel ch.
  • The worker() function is a goroutine that simulates work and sends the result to the channel.
  • The main() function starts the worker goroutine and then waits to receive the result from the channel.

Using Buffered Channels

Buffered channels are useful when you want to decouple senders and receivers, allowing for asynchronous communication. Let’s look at an example:

package main

import (

func producer(ch chan int) {
    for i := 0; i < 5; i++ {
        fmt.Println("Producer: Sent:", i)

        // Send value to channel
        ch <- i

        // Simulate work
        time.Sleep(time.Second / 2)

    // Close the channel when done

    fmt.Println("Producer: Closed")

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

    fmt.Println("Main: Start worker goroutine")

    // Start producer goroutine
    go producer(ch)

    // Wait for 1 second before receiving

    fmt.Println("Main: Waiting for result...")

    // Receive values from channel
    for val := range ch {
        fmt.Println("Main: Received:", val)

    fmt.Println("Main: Finished")


$ go run channel-bu.go
Main: Start worker goroutine
Producer: Sent: 0
Producer: Sent: 1
Main: Waiting for result...
Producer: Sent: 2
Main: Received: 0
Main: Received: 1
Main: Received: 2
Producer: Sent: 3
Main: Received: 3
Producer: Sent: 4
Main: Received: 4
Producer: Closed
Main: Finished

In this example:

  • We create a buffered channel ch with a capacity of 3.
  • The producer() function sends values to the channel asynchronously.
  • The main() function receives values from the channel and prints them.

Channels are a fundamental feature of Go’s concurrency model, providing a safe and efficient mechanism for goroutines to communicate and synchronize their execution. Understanding the differences between unbuffered and buffered channels, and how to use them effectively, is essential for writing concurrent Go programs. By leveraging channels, you can write scalable and robust concurrent applications in Go.

Channel Pitfalls

  • Deadlocks: Goroutines can deadlock if they’re expecting data from a channel that’s not being sent or if they’re waiting to send data to a channel that’s not being received.
  • Buffered Channels: Be cautious when using buffered channels, as they can lead to increased memory usage if not managed properly.


Goroutines and channels are fundamental concurrency primitives in Go that enable developers to write concurrent and scalable programs efficiently. By leveraging goroutines for concurrent execution and channels for communication and synchronization between goroutines, Go provides a robust model for building concurrent software. Understanding these concepts is essential for effectively utilizing Go’s concurrency features and writing robust concurrent programs.

Remember, Something is usable if it behaves exactly as expected.
Happy coding! 🚀