Getting Started with Goroutines in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting up Go

  4. Goroutines 1. Creating Goroutines 2. Synchronization using Channels 3. Waiting for Goroutines to Finish

  5. Conclusion

Introduction

Welcome to this tutorial on getting started with Goroutines in Go! In this tutorial, we will explore the concept of Goroutines, a lightweight thread of execution in Go, and learn how to utilize them for concurrent programming. By the end of this tutorial, you will be able to leverage Goroutines to perform tasks concurrently and enhance the efficiency of your Go programs.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of the Go programming language. Familiarity with concepts like functions, variables, and control flow will be beneficial.

Setting up Go

Before we dive into Goroutines, make sure you have Go set up on your machine. You can download and install Go from the official website (https://golang.org). Follow the installation instructions specific to your operating system.

To verify that Go is installed correctly, open a terminal and run the following command:

go version

You should see the installed version of Go printed on the console.

Goroutines

Creating Goroutines

In Go, Goroutines are independently executing functions or methods. They are lightweight and allow concurrent execution of code. Creating a Goroutine is as simple as prefixing the function or method call with the keyword go.

Let’s consider a simple example where we want to print the numbers from 1 to 5 concurrently using Goroutines:

package main

import (
	"fmt"
	"time"
)

func printNumbers() {
	for i := 1; i <= 5; i++ {
		fmt.Println(i)
		time.Sleep(1 * time.Second)
	}
}

func main() {
	go printNumbers()

	// Allowing the Goroutine to finish execution
	time.Sleep(6 * time.Second)
}

Here, we have a function printNumbers() that prints numbers from 1 to 5 with a time delay of 1 second between each number. We create a Goroutine by calling go printNumbers() in the main function. The time.Sleep(6 * time.Second) is used to prevent the program from exiting before the Goroutine completes its execution.

When you run the above program, you will see the numbers being printed in a concurrent manner.

Synchronization using Channels

To synchronize Goroutines and communicate between them, Go provides channels. Channels allow Goroutines to send and receive values to and from each other.

Let’s modify the previous example to use a channel for synchronization:

package main

import (
	"fmt"
	"time"
)

func printNumbers(c chan int) {
	for i := 1; i <= 5; i++ {
		c <- i
		time.Sleep(1 * time.Second)
	}
	close(c)
}

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

	go printNumbers(c)

	for num := range c {
		fmt.Println(num)
	}

	// Waiting for user input before exiting
	var input string
	fmt.Scanln(&input)
}

In this example, we create a channel c using c := make(chan int). The Goroutine printNumbers() now accepts the channel as a parameter and sends the numbers to the channel using c <- i. After sending all the numbers, we close the channel using close(c).

In the main function, we use a for range loop to iterate over the values received from the channel using num := range c. This loop will terminate once the channel is closed. Finally, we wait for user input before exiting, so the program doesn’t terminate immediately.

Waiting for Goroutines to Finish

In some cases, it may be necessary to wait for multiple Goroutines to finish their execution. Go provides the sync package to handle such scenarios.

Let’s extend the previous example to wait for multiple Goroutines to finish:

package main

import (
	"fmt"
	"sync"
	"time"
)

func printNumbers(c chan int, wg *sync.WaitGroup) {
	defer wg.Done()

	for i := 1; i <= 5; i++ {
		c <- i
		time.Sleep(1 * time.Second)
	}
	close(c)
}

func main() {
	c := make(chan int)
	var wg sync.WaitGroup

	// Define the number of Goroutines
	numGoroutines := 3

	// Add Goroutines to the WaitGroup
	wg.Add(numGoroutines)

	for i := 0; i < numGoroutines; i++ {
		go printNumbers(c, &wg)
	}

	go func() {
		wg.Wait()
		close(c)
	}()

	for num := range c {
		fmt.Println(num)
	}

	// Waiting for user input before exiting
	var input string
	fmt.Scanln(&input)
}

In this example, we introduce the sync.WaitGroup variable wg to wait for multiple Goroutines to finish. We add the required number of Goroutines to the WaitGroup using wg.Add(numGoroutines). Each Goroutine calls wg.Done() using defer wg.Done() to inform the WaitGroup that it has finished execution.

After creating the Goroutines, we spawn an anonymous Goroutine that waits for all the Goroutines to finish using wg.Wait(). Once all Goroutines have completed, we close the channel using close(c).

Conclusion

Congratulations! You have learned how to utilize Goroutines in Go for concurrent programming. We covered the creation of Goroutines, synchronization using channels, and waiting for Goroutines to finish. You can now leverage Goroutines to enhance the efficiency and performance of your Go programs.

Feel free to explore more about Goroutines and experiment with different concurrency patterns in Go. Happy coding!

Published:

Related Articles