Concurrency with Goroutines @ benhall/golang-demo

Concurrency with Goroutines

Go’s concurrency model, built on goroutines and channels, allows for efficient handling of multiple tasks simultaneously. This enhances performance and responsiveness, especially in scenarios requiring I/O operations or complex computations.

What are Goroutines?

Goroutines are lightweight, concurrent execution units managed by the Go runtime. They are created using the go keyword, which launches a new goroutine to execute a function concurrently. [Source: https://go.dev/blog/concurrency-is-not-parallelism]

Example:

package main
      
      import (
      "fmt"
      "time"
      )
      
      func say(s string) {
      for i := 0; i < 5; i++ {
      time.Sleep(100 * time.Millisecond)
      fmt.Println(s)
      }
      }
      
      func main() {
      go say("world")
      say("hello")
      }

Why is Concurrency with Goroutines Important?

Concurrency empowers Go programs to:

Improve Responsiveness: Allowing tasks to run in parallel prevents blocking of the main thread, ensuring responsiveness to user interactions.
Maximize CPU Utilization: Goroutines effectively leverage multi-core processors, enabling parallel execution of tasks for enhanced performance.
Simplified Code Structure: Go’s concurrency features allow for clean and modular code, making it easier to manage complex systems.

Channels

Channels act as communication pathways between goroutines. They provide a safe and synchronized method for passing data between concurrently running functions.

Example:

package main
      
      import (
      "fmt"
      )
      
      func sum(s []int, c chan int) {
      sum := 0
      for _, v := range s {
      sum += v
      }
      c <- sum // Send sum to channel c
      }
      
      func main() {
      a := []int{7, 2, 8, -9, 4, 0}
      
      c := make(chan int) // Create a channel
      go sum(a[:len(a)/2], c)
      go sum(a[len(a)/2:], c)
      
      x := <-c // Receive from c
      y := <-c // Receive from c
      fmt.Println(x, y, x+y)
      }

This example demonstrates how channels facilitate communication and synchronization between goroutines, allowing for efficient data processing.

Concurrency with Goroutines @ benhall/golang-demo