Goroutines

Introduction

In the world of programming, especially in languages like Go, concurrency is a powerful feature that allows you to write efficient and scalable applications. Goroutines are one of the core components that enable concurrent execution in Go. A goroutine is a lightweight thread managed by the Go runtime. Unlike traditional threads, goroutines are much cheaper to create and manage, making them ideal for handling many concurrent tasks.

Concept

A goroutine is a function that is capable of running concurrently with other functions. When you start a new goroutine, it runs in parallel with the calling function. This allows your program to perform multiple operations simultaneously, improving performance and responsiveness.

To create a goroutine, you use the go keyword followed by a function call. Here's a simple example:

1package main
2 
3import (
4  "fmt"
5  "time"
6)
7 
8func sayHello() {
9  for i := 0; i < 5; i++ {
10      time.Sleep(1 * time.Second)
11      fmt.Println("Hello from goroutine")
12  }
13}
14 
15func main() {
16  go sayHello()
17  fmt.Println("Hello from main function")
18 
19  // Wait for a while to see the output
20  time.Sleep(6 * time.Second)
21}

In this example, the sayHello function is executed as a goroutine. The main function prints "Hello from main function" and then waits for 6 seconds using time.Sleep. During this wait, the goroutine runs concurrently, printing "Hello from goroutine" every second.

Examples

Example 1: Basic Goroutine Usage

Let's look at a more detailed example where we create multiple goroutines to perform different tasks simultaneously:

1package main
2 
3import (
4  "fmt"
5  "time"
6)
7 
8func printNumbers() {
9  for i := 1; i <= 5; i++ {
10      time.Sleep(200 * time.Millisecond)
11      fmt.Println(i)
12  }
13}
14 
15func printLetters() {
16  for c := 'a'; c <= 'e'; c++ {
17      time.Sleep(300 * time.Millisecond)
18      fmt.Println(string(c))
19  }
20}
21 
22func main() {
23  go printNumbers()
24  go printLetters()
25 
26  // Wait for a while to see the output
27  time.Sleep(2 * time.Second)
28}

In this example, printNumbers and printLetters are executed as separate goroutines. The numbers and letters are printed concurrently, demonstrating how goroutines can be used to perform multiple tasks simultaneously.

Example 2: Goroutine with Channels

While goroutines allow concurrent execution, they don't provide a way for different goroutines to communicate directly. Channels are another powerful feature in Go that enable communication between goroutines. We'll explore channels in the next section, but here's a brief example of how you might use them:

1package main
2 
3import (
4  "fmt"
5  "time"
6)
7 
8func worker(id int, ch chan int) {
9  for n := range ch {
10      fmt.Printf("Worker %d received %d
11", id, n)
12      time.Sleep(1 * time.Second)
13  }
14}
15 
16func main() {
17  ch := make(chan int)
18 
19  for i := 1; i <= 3; i++ {
20      go worker(i, ch)
21  }
22 
23  for j := 1; j <= 5; j++ {
24      ch <- j
25  }
26 
27  close(ch)
28 
29  // Wait for a while to see the output
30  time.Sleep(6 * time.Second)
31}

In this example, three goroutines (workers) are created and they receive integers from a channel. The main function sends numbers into the channel, and the workers process them concurrently.

What's Next?

Now that you have a good understanding of how to use goroutines for concurrent execution, the next step is to learn about channels. Channels provide a way for different goroutines to communicate with each other, enabling more complex and coordinated concurrency patterns. Stay tuned as we explore channels in the upcoming sections!

By mastering goroutines and channels, you'll be well-equipped to write efficient and scalable Go applications that can handle multiple tasks concurrently.