1. Concurrency

If the computer we're running our code on has multiple cores, we can even execute multiple tasks at exactly the same time. If we're running on a single core, a single core executes code at almost the same time by switching between tasks very quickly. Either way, the code we write looks the same in Go and takes advantage of whatever resources are available.

How Does Concurrency Work in Go?

Go was designed to be concurrent, which is a trait fairly unique to Go. It excels at performing many tasks simultaneously safely using a simple syntax.

There isn't a popular programming language in existence where spawning concurrent execution is quite as elegant, at least in my opinion.

Concurrency is as simple as using the go keyword when calling a function:

go doSomething()

In the example above, doSomething() will be executed concurrently with the rest of the code in the function. The go keyword is used to spawn a new goroutine.

What is Concurrency?

Concurrency = doing multiple things at the same time (or appearing to)

Multiple Cores

Core 1: Task A running
Core 2: Task B running
Core 3: Task C running
(All truly simultaneous)

Single Core

Core 1: Task A → Task B → Task C → Task A → Task B...
(Switching so fast it feels simultaneous)

The go Keyword

Spawns a goroutine (concurrent execution):

go doSomething()

This runs doSomething() concurrently while the rest of your code continues.

Basic Example

1

Without Concurrency (Sequential)

func main() {
    task1()  // Wait for this to finish
    task2()  // Then do this
    task3()  // Then do this
}
// Total time: task1 + task2 + task3

2

With Concurrency (Parallel)

func main() {
    go task1()  // Start this
    go task2()  // Start this at the same time
    go task3()  // Start this at the same time
}
// Total time: ~longest task

Real Example

package main

import (
    "fmt"
    "time"
)

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

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

func main() {
    // Sequential (one after another)
    printNumbers()  // 1 2 3 4 5
    printLetters()  // a b c d e
    // Takes ~1 second total
}

Output:

1 2 3 4 5 a b c d e

With Concurrency

func main() {
    // Concurrent (at the same time)
    go printNumbers()
    go printLetters()
    
    time.Sleep(600 * time.Millisecond)  // Wait for goroutines
}

Output (interleaved):

1 a 2 b 3 c 4 d 5 e

Numbers and letters print at the same time!

Goroutines

A goroutine is a lightweight thread managed by Go:

go myFunction()        // Spawn a goroutine
go anotherFunction()   // Spawn another

Key facts:

• Very lightweight (can have thousands)

• Managed by Go runtime, not OS

• Start with go keyword

Important: main() does not wait for goroutines. If main() exits, the program terminates and any running goroutines are killed.

Example showing the issue:

func main() {
    go doSomething()
    // main() exits immediately, killing the goroutine!
}

A quick (but crude) way to wait:

func main() {
    go doSomething()
    time.Sleep(1 * time.Second)  // Wait for goroutine
}

(We'll learn better ways to wait later, e.g., sync.WaitGroup, channels.)

Practical Example

func sendEmail(email string) {
    time.Sleep(1 * time.Second)  // Simulate slow operation
    fmt.Printf("Email sent to %s\n", email)
}

func main() {
    emails := []string{"[e-mail]", "[e-mail]", "[e-mail]"}
    
    // Sequential: takes 3 seconds
    for _, email := range emails {
        sendEmail(email)
    }
    
    // Concurrent: takes ~1 second
    for _, email := range emails {
        go sendEmail(email)
    }
    
    time.Sleep(2 * time.Second)  // Wait for all goroutines
}

Why Go is Good at This

Other languages:

// Java
new Thread(() -> doSomething()).start();

# Python
import threading
thread = threading.Thread(target=do_something)
thread.start()

Go:

go doSomething()

Simple and elegant!

Concurrency vs Parallelism

Concurrency: Managing multiple tasks (may or may not run at exact same time) Parallelism: Actually running multiple tasks at exact same time

Go handles both automatically based on available CPU cores.

Key Takeaways

1. go keyword spawns a goroutine

2. Goroutines are lightweight concurrent tasks

3. Very simple syntax - just add go before function call

4. Main doesn't wait - need to handle synchronization

5. Works on any hardware - Go optimizes automatically

Quick Reference

// Normal function call (sequential)
doSomething()

// Concurrent function call
go doSomething()

// Multiple concurrent calls
go task1()
go task2()
go task3()

Rule: Use go when you want something to happen concurrently while your code continues running.

Assignment

At Textio we send a lot of network requests. Each email we send must go out over the internet. To serve our millions of customers, we need a single Go program to be capable of sending thousands of emails at once.

Edit the sendEmail() function to execute its anonymous function concurrently so that the "received" message prints after the "sent" message.

Suggested edit (launch the anonymous function as a goroutine after printing "sent"):

func sendEmail(email string) {
    time.Sleep(1 * time.Second)  // Simulate slow operation
    fmt.Printf("Email sent to %s\n", email)

    // Execute anonymous function concurrently.
    // Since we print "sent" before starting this goroutine,
    // "received" will always print after "sent".
    go func(e string) {
        // Simulate some post-send handling
        fmt.Printf("Email received by %s\n", e)
    }(email)
}

This ensures the anonymous function runs concurrently and its "received" message happens after the "sent" message for the same email.