Tag Archives: Concurrency

• on 24 Aug 2023
• By psid
• Golang

Goroutines – Concurrency in Golang

Goroutines are a fundamental feature in Go that enable concurrent programming. A goroutine is a lightweight thread of execution managed by the Go runtime. It allows you to run functions concurrently, potentially achieving better performance and resource utilization compared to traditional threads.

Here are the key points to understand about goroutines in Go:

1. Goroutine Creation:
   • Goroutines are created using the go keyword followed by a function call.
   • Creating a goroutine starts a new concurrent execution, which runs concurrently with the calling code and other goroutines.
2. Concurrency vs. Parallelism:
   • Concurrency means multiple tasks can be in progress at the same time, even if they’re not executing simultaneously.
   • Parallelism means multiple tasks are executed simultaneously by utilizing multiple CPU cores.
3. Lightweight:
   • Goroutines are very lightweight compared to traditional threads, allowing you to create thousands or even millions of goroutines without significant overhead.
4. Communication:
   • Goroutines communicate and synchronize using channels, which provide a safe way to pass data between them.
5. Main Goroutine:
   • The main function itself runs as a goroutine, known as the main goroutine.
   • When the main goroutine terminates, other goroutines are terminated as well, regardless of their state.
6. Concurrency with Channels:
   • Channels are used for communication and synchronization between goroutines.
   • Channels allow sending and receiving data with the chan keyword.
7. Concurrency Patterns:
   • Go provides various concurrency patterns, such as fan-out/fan-in, worker pools, and select statements for handling multiple channels.
8. Sync Package:
   • The sync package provides synchronization primitives like WaitGroup, Mutex, and RWMutex for coordinating goroutines.
9. Error Handling:
   • Proper error handling is crucial with goroutines to avoid silent failures and to ensure all goroutines complete successfully.
10. Use Cases:
    • Goroutines are used for parallelizing I/O-bound operations, processing tasks concurrently, and creating scalable network servers.

Here’s a simple example of using goroutines:

package main

import (
	"fmt"
	"time"
)

func printNumbers() {
	for i := 1; i <= 5; i++ {
		fmt.Printf("%d ", i)
		time.Sleep(time.Millisecond * 500)
	}
}

func printLetters() {
	for char := 'a'; char <= 'e'; char++ {
		fmt.Printf("%c ", char)
		time.Sleep(time.Millisecond * 400)
	}
}

func main() {
	go printNumbers() // Start a goroutine to print numbers concurrently
	go printLetters() // Start a goroutine to print letters concurrently

	// Give goroutines some time to finish
	time.Sleep(time.Second * 3)
	fmt.Println("\nMain function exits")
}

Output:

1 a 2 3 b 4 c 5 d e 
Main function exits

In this example, the printNumbers and printLetters functions are executed concurrently as goroutines. The time.Sleep calls allow us to see their interleaved output. Keep in mind that the order of execution between goroutines is not guaranteed.

How to create a Goroutine?

Creating a goroutine in Go is quite straightforward. You simply use the go keyword followed by a function call. This initiates the execution of the specified function concurrently as a goroutine. Here’s the basic syntax:

go functionName(arguments)

Here’s a step-by-step guide on how to create and use a goroutine:

1. Define the function you want to run concurrently as a goroutine.
2. Use the go keyword followed by the function call to create the goroutine.
3. Ensure that the main goroutine (the one running main()) doesn’t exit before the other goroutines complete. You can use synchronization mechanisms like channels or sync.WaitGroup to achieve this.

Here’s a simple example:

package main

import (
	"fmt"
	"time"
)

func printNumbers() {
	for i := 1; i <= 5; i++ {
		fmt.Printf("%d ", i)
		time.Sleep(time.Millisecond * 500)
	}
}

func printLetters() {
	for char := 'a'; char <= 'e'; char++ {
		fmt.Printf("%c ", char)
		time.Sleep(time.Millisecond * 400)
	}
}

func main() {
	go printNumbers() // Start a goroutine to print numbers concurrently
	go printLetters() // Start a goroutine to print letters concurrently

	// Give goroutines some time to finish
	time.Sleep(time.Second * 3)
	fmt.Println("\nMain function exits")
}

Output :

1 a 2 3 b 4 c 5 d e 
Main function exits

In this example, the printNumbers and printLetters functions are executed concurrently as goroutines. The time.Sleep calls are used to allow some time for the goroutines to finish before the main function exits.

Advantages of Goroutines

Goroutines offer several advantages that make concurrent programming in Go efficient and manageable:

1. Lightweight Concurrency: Goroutines are extremely lightweight compared to traditional threads, allowing you to create and manage thousands of them with minimal overhead. This enables efficient utilization of system resources.
2. Concurrency without Complexity: Goroutines abstract away much of the complexity associated with traditional multi-threading. They are managed by the Go runtime, which handles tasks like scheduling and resource management, freeing developers from dealing with low-level thread management.
3. Efficient Utilization of CPU Cores: Goroutines are multiplexed onto a smaller number of operating system threads, allowing the Go runtime to efficiently utilize CPU cores. This is especially beneficial for applications running on multi-core systems.
4. Fast Startup and Low Memory Footprint: Goroutines have a faster startup time and lower memory overhead compared to traditional threads. This makes them well-suited for tasks with short lifetimes or high turnover.
5. Synchronous Codebase: Go promotes a synchronous programming style where concurrency is achieved through goroutines and channels. This makes code more readable, debuggable, and predictable compared to managing explicit asynchronous callbacks.
6. Data Sharing with Channels: Goroutines communicate and synchronize via channels, providing a safe and structured way to share data between concurrent tasks without the need for explicit locks or synchronization mechanisms.
7. Scalability: Goroutines enable the creation of highly scalable programs. Adding more concurrent tasks is as simple as creating more goroutines, and Go’s runtime scheduler manages their execution efficiently.
8. Natural Concurrency: The use of goroutines feels natural in Go due to its clean syntax and explicit concurrency model. This encourages developers to utilize concurrency in designing scalable and responsive applications.
9. Avoiding Deadlocks and Race Conditions: The design of channels and the language’s concurrency primitives helps to minimize the occurrence of common concurrency issues like deadlocks and race conditions.
10. Easy Error Handling: Go’s idiomatic error handling style is well-suited for concurrent programming. Error propagation and handling are straightforward and less error-prone than other asynchronous patterns.
11. Parallelism Made Easier: Goroutines simplify the implementation of parallel algorithms. Parallelizing tasks and processing data concurrently becomes intuitive with the ability to launch many goroutines without excessive management overhead.
12. Smooth Integration with Libraries: Goroutines can be used seamlessly with standard library functions and third-party libraries, allowing you to add concurrency to existing codebases without significant modifications.

Overall, goroutines make concurrent programming accessible, efficient, and manageable in Go, making it easier to build scalable and responsive applications while minimizing the complexities associated with traditional multi-threading.

Anonymous Goroutine

An anonymous goroutine refers to a goroutine that is launched without explicitly naming the function that it executes. Anonymous goroutines are often used for short-lived concurrent tasks where you don’t need to refer to the goroutine directly.

Here’s how you can create an anonymous goroutine:

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("Main: Starting anonymous goroutine")

	// Launch an anonymous goroutine
	go func() {
		for i := 1; i <= 5; i++ {
			fmt.Printf("%d ", i)
			time.Sleep(time.Millisecond * 500)
		}
	}()

	fmt.Println("Main: Waiting for goroutine to finish")
	time.Sleep(time.Second * 3)
	fmt.Println("\nMain: Done")
}

Output :

Main: Starting anonymous goroutine
Main: Waiting for goroutine to finish
1 2 3 4 5 
Main: Done

In this example, an anonymous function containing the goroutine logic is defined and immediately executed using the go keyword. This creates a new concurrent execution without explicitly naming the function.

Anonymous goroutines are useful when you need a simple, short-lived concurrent task and don’t need to reference or communicate with the goroutine elsewhere in the code. They are commonly used for tasks like periodic cleanup, background processing, or logging without disrupting the main program flow.