DEV Community

Cover image for Golang Concurrency Model Explained
Kuldeep Singh
Kuldeep Singh

Posted on

Golang Concurrency Model Explained


Understanding Concurrency

Concurrency refers to the execution of tasks independently over the same period, allowing systems to make progress on multiple tasks simultaneously. It doesn't necessarily mean tasks are executed at the same time, but they start, run, and complete within overlapping time periods.

Importance of Concurrency

Concurrency provides a way to structure a solution to solve complex tasks that can run independently. It's beneficial when different tasks do not need to share computational resources and can help increase efficiency, especially in multicore and distributed systems.

Concurrency Vs. Parallelism

Concurrency and parallelism, though often used interchangeably, are not identical. Concurrency is about dealing with multiple tasks at once (not necessarily simultaneously), while parallelism involves executing multiple tasks at the same time.

// Concurrent execution
func main() {
    go fmt.Println("Hello from another task") // starts a new goroutine
    fmt.Println("Hello from main task")

// Parallel execution - requires a multi-core processor
func main() {
    runtime.GOMAXPROCS(2) // set maximum number of CPUs that can be executing simultaneously
    go fmt.Println("Hello from another task")
    fmt.Println("Hello from main task")

Enter fullscreen mode Exit fullscreen mode

Introduction to Golang

Go, or Golang, is a statically-typed, compiled language developed at Google, known for its simplicity, efficiency, and strong support for concurrent programming patterns.

Why Golang for Concurrency?

Golang makes it easy to write concurrent programs, thanks to features like goroutines and channels.

Key Features of Golang

Golang has several features that make it a good choice for concurrent programming: goroutines, channels, and the select statement.

Golang Concurrency Model

Go's concurrency model, often referred to as Communicating Sequential Processes (CSP), is centered around goroutines and channels.


Goroutines are functions or methods that run concurrently with other functions or methods. They're lightweight threads managed by the Go runtime.

How Goroutines Work?

Use the go keyword before a function call to start a goroutine.

package main

import (

func printFrom(another string) {
    for i := 0; i < 5; i++ {
        fmt.Println(another, ":", i)

func main() {
    go printFrom("goroutine") // start a new goroutine
Enter fullscreen mode Exit fullscreen mode

Channels in Golang

Channels are the pipes that connect concurrent goroutines. You can send values into channels from one goroutine and receive those values into another goroutine.

Unbuffered vs Buffered Channels

Unbuffered channels block senders until receivers are ready, and vice versa. Buffered channels have a queue of elements and do not block until the queue is full.

// Unbuffered Channel
ch := make(chan int) // creates an unbuffered channel

// Buffered Channel
ch := make(chan int, 2) // creates a buffered channel with capacity for 2 integers

Enter fullscreen mode Exit fullscreen mode

Select Statement

The select statement is used to choose from multiple send/receive channel operations. It blocks until one of its cases can run, then it executes that case.

Use Case of Select Statement

package main

import (

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
        quit <- 0
    fibonacci(c, quit)

Enter fullscreen mode Exit fullscreen mode

Real World Applications of Golang Concurrency

Golang's concurrency model is used in many real-world applications. For example, it's used in Docker for containerization and Kubernetes for container orchestration, and by companies like Uber for handling high volumes of network requests.

Case Studies

  • Docker: Docker uses Golang due to its strong support for concurrent process handling, which is essential for containerization.
  • Kubernetes: Kubernetes, an open-source system for automating deployment, scaling, and management of containerized applications, is also written in Go.


Golang provides powerful primitives to deal with concurrent programming. Its simple and efficient concurrency model, based on goroutines, channels, and the select statement, makes it an ideal choice for developers working with concurrent processes.

If you’re interested in learning more about programming and related topics, we invite you to check out our website We offer valuable resources and insights.

You can find us on Twitter and Facebook.

Download my first ebook about mastering markdown, from here: Download , reviews and recommendations are appreciated.

Top comments (0)