What is concurrency and parallelism in go language?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Go, concurrency and parallelism are critical concepts for efficiently managing and executing tasks. While often used interchangeably, they represent different aspects of executing multiple tasks in a program. Understanding the distinction between concurrency and parallelism is crucial for leveraging Go's features effectively. This guide explores these concepts, their implementation in Go, and their practical applications.
Concurrency vs Parallelism
Concurrency
Concurrency refers to the ability of a system to handle multiple tasks at the same time, making progress on each task without necessarily executing them simultaneously. It's about dealing with many things at once, but not necessarily executing them all at the same time. In Go, concurrency is primarily achieved using Goroutines.
Key Characteristics of Concurrency:

Task Management: Concurrency allows a program to manage multiple tasks by interleaving their execution. This can improve responsiveness and resource utilization without requiring simultaneous execution.

Goroutines: Goroutines are lightweight threads managed by the Go runtime. They enable concurrent execution of functions or methods. You can launch many Goroutines to handle tasks like I/O operations, network requests, or any other time-consuming tasks.
Example:
package main

import (
    "fmt"
    "time"
)

func fetchData(id int) {
    fmt.Printf("Fetching data for ID: %d
", id)
    time.Sleep(2 * time.Second)
    fmt.Printf("Data fetched for ID: %d
", id)
}

func main() {
    for i := 1; i &#x3C;= 3; i++ {
        go fetchData(i) // Launch Goroutine
    }
    time.Sleep(5 * time.Second) // Wait for Goroutines to complete
}

In this example, fetchData is executed concurrently for different IDs using Goroutines.

Concurrency Primitives: Go provides concurrency primitives like Channels and the select statement for managing and synchronizing Goroutines.
Example:
package main

import "fmt"

func generateNumbers(ch chan&#x3C;- int) {
    for i := 1; i &#x3C;= 5; i++ {
        ch &#x3C;- i
    }
    close(ch)
}

func main() {
    ch := make(chan int)
    go generateNumbers(ch)

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

This example demonstrates using a Channel to communicate between Goroutines.

Parallelism
Parallelism involves executing multiple tasks simultaneously, often leveraging multiple processors or cores. It focuses on the actual simultaneous execution of tasks to improve performance and speed. In Go, parallelism can be achieved through the concurrent execution of Goroutines, which can be scheduled on multiple OS threads.
Key Characteristics of Parallelism:

Simultaneous Execution: Parallelism enables tasks to run at the same time, making full use of available CPU cores. It improves performance for CPU-bound tasks by distributing the workload across multiple processors.

Concurrency Model: Go’s concurrency model, which uses Goroutines, naturally supports parallelism. The Go runtime scheduler maps Goroutines to OS threads, allowing for parallel execution when multiple CPU cores are available.
Example:
package main

import (
    "fmt"
    "runtime"
    "sync"
)

func computeTask(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Task %d started
", id)
    // Simulate computation
    time.Sleep(1 * time.Second)
    fmt.Printf("Task %d completed
", id)
}

func main() {
    runtime.GOMAXPROCS(4) // Set the maximum number of CPU cores to use
    var wg sync.WaitGroup

for i := 1; i &#x3C;= 4; i++ {
        wg.Add(1)
        go computeTask(i, &#x26;wg) // Launch Goroutines for parallel execution
    }
    wg.Wait() // Wait for all Goroutines to complete
}

This example shows parallel execution of tasks with Goroutines scheduled on multiple CPU cores.

Parallelism in Go: Go’s runtime scheduler manages Goroutines and schedules them on multiple OS threads to achieve parallelism. Setting the GOMAXPROCS variable controls the number of OS threads used for parallel execution.

Practical Examples

Concurrent Task Management:
Example:
package main

import (
    "fmt"
    "time"
)

func task(id int) {
    fmt.Printf("Task %d started
", id)
    time.Sleep(2 * time.Second)
    fmt.Printf("Task %d completed
", id)
}

func main() {
    for i := 1; i &#x3C;= 5; i++ {
        go task(i) // Launch Goroutines for concurrent execution
    }
    time.Sleep(10 * time.Second) // Wait for all tasks to complete
}

This example demonstrates concurrent execution of multiple tasks using Goroutines.

Parallel Computation:
Example:
package main

import (
    "fmt"
    "runtime"
    "sync"
)

func parallelTask(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Task %d is running
", id)
    time.Sleep(1 * time.Second) // Simulate work
    fmt.Printf("Task %d finished
", id)
}

func main() {
    runtime.GOMAXPROCS(4) // Use multiple CPU cores
    var wg sync.WaitGroup

for i := 1; i &#x3C;= 4; i++ {
        wg.Add(1)
        go parallelTask(i, &#x26;wg) // Run tasks in parallel
    }
    wg.Wait() // Wait for all tasks to finish
}

This example demonstrates parallel execution of tasks using Goroutines with multiple CPU cores.

Conclusion
Concurrency and parallelism are fundamental concepts in Go that enable efficient task management and execution. Concurrency, achieved through Goroutines, allows handling multiple tasks simultaneously, improving responsiveness and resource utilization. Parallelism, on the other hand, leverages multiple CPU cores for simultaneous task execution, enhancing performance for CPU-bound operations. Understanding these concepts and their implementation in Go helps in writing efficient, scalable programs that leverage modern hardware capabilities.

What is concurrency and parallelism in go language?

Similar Questions