What is Goroutine in Go: Simple Explanation and Example

A goroutine in Go is a lightweight thread managed by the Go runtime that allows functions to run concurrently. It is easy to start with the go keyword before a function call, enabling efficient multitasking without heavy system threads.

How It Works

Think of a goroutine as a small worker that can run tasks independently alongside other workers. Unlike traditional threads, goroutines are very lightweight and managed by Go's runtime scheduler, which efficiently shares CPU time among many goroutines.

When you start a goroutine, it runs concurrently with the rest of your program. The Go scheduler handles switching between goroutines, so you don't have to manage threads manually. This is like having many helpers working on different parts of a project at the same time without getting in each other's way.

Example

This example shows how to start a goroutine that prints a message while the main function continues running.

go

package main

import (
	"fmt"
	"time"
)

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

func main() {
	go sayHello() // start goroutine
	fmt.Println("Hello from main function!")
	// wait a moment to let goroutine finish
	time.Sleep(100 * time.Millisecond)
}

Output

Hello from main function!
Hello from goroutine!

When to Use

Use goroutines when you want your program to do many things at once without waiting for each task to finish. For example, they are great for handling multiple network requests, reading files while processing data, or running background tasks like timers.

Goroutines help improve performance and responsiveness, especially in servers or applications that handle many users or tasks simultaneously.

Key Points

• Goroutines are lightweight and managed by Go's runtime scheduler.
• Start a goroutine by placing go before a function call.
• They run concurrently, allowing multitasking without heavy threads.
• Use them to improve performance in I/O, network, and background tasks.

Key Takeaways

Goroutines let you run functions concurrently with simple syntax using the go keyword.

They are lightweight and managed by Go's scheduler, making multitasking efficient.

Use goroutines to handle multiple tasks like network calls or background jobs simultaneously.

Always ensure your program waits or synchronizes properly to see goroutine results.