Understanding Goroutines: The Lightweight Champions of Go

What the Heck is a Goroutine?

Let's Break It Down

The Basics: Creating a Goroutine

func main() {
go fmt.Println("I'm running in a goroutine!")
// Main continues without waiting
time.Sleep(time.Millisecond)
}

Why Goroutines Are Awesome

1. They're Lightweight
• A regular thread: "I need 1MB of memory!" 🏋️‍♂️
• A goroutine: "I'll start with 2KB, thanks!" 🤸‍♂️

2. They're Scalable

// Try this with regular threads and watch your computer cry
for i := 0; i < 100000; i++ {
    go func(id int) {
        fmt.Printf("Goroutine %d says hi!\n", id)
    }(i)
}

3. They're Smart

• Go's runtime juggles them automatically

• Like having a really efficient personal assistant for your tasks

Deep Dive into Goroutines: From OS Threads to Go's Runtime Magic

What Exactly is a Goroutine?

OS Threads vs Goroutines

Memory Usage

• OS Thread:
• Fixed stack size (often 1-2 MB on modern systems)
• Stack size must be determined at thread creation
• Memory overhead is significant

• Goroutine:
• Starts with tiny stack (2 KB in current versions)
• Stack grows and shrinks dynamically
• Can create millions of goroutines on modern hardware

Creation Time

• C++ OS Thread Creation:

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>

class ThreadManager {
private:
static const int STACK_SIZE = 8 * 1024 * 1024;  // 8MB stack size
std::vectorstd::thread threads;

public:
void createThread(int id) {
// Thread attributes to set stack size
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setstacksize(&attr, STACK_SIZE);

// Create actual thread - heavy operation!
threads.emplace_back(id {
std::cout << "Thread " << id << " starting\n";
// Some work here
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::cout << "Thread " << id << " finished\n";
});
}

void waitForAll() {
for (auto& thread : threads) {
thread.join();
}
}
};

int main() {
ThreadManager manager;

// Creating just 1000 threads - this is already a lot!
for (int i = 0; i < 1000; i++) {
try {
manager.createThread(i);
} catch (const std::system_error& e) {
std::cerr << "Failed to create thread: " << e.what() << std::endl;
break;
}
}

manager.waitForAll();
return 0;
}

1. Each thread needs ~8MB stack space by default

2. Thread creation is a system call (expensive!)

3. Thread scheduling is handled by OS

4. Resources are managed manually

5. Creating 1000 threads might fail due to system limits

Same Thing in Go

• Goroutine Creation:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    
    // Creating 1,000,000 goroutines - no problem!
    for i := 0; i < 1_000_000; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Printf("Goroutine %d starting\n", id)
            time.Sleep(100 * time.Millisecond)
            fmt.Printf("Goroutine %d finished\n", id)
        }(i)
    }

    wg.Wait()
}

Let's Look at the System Level

// What happens under the hood when creating a thread in C++
pthread_t thread;
pthread_attr_t attr;

// 1. Initialize thread attributes
pthread_attr_init(&attr);

// 2. Set stack size (default is huge!)
pthread_attr_setstacksize(&attr, 8 * 1024 * 1024);

// 3. Create thread (system call)
int result = pthread_create(&thread, &attr, threadFunction, arg);
if (result != 0) {

// Handle error - system resources might be exhausted!
}

// 4. Clean up attributes
pthread_attr_destroy(&attr);

1. Allocate ~8MB memory for stack

2. Set up kernel structures

3. Add thread to scheduler

4. Context switch overhead is high

// What happens when you do:
go myFunction()

// Go runtime does:
// 1. Allocate tiny 2KB stack
g := newgoroutine()
g.stack = allocate(2048)// 2KB initial stack

// 2. Add to local P's queue (no system call!)
p.runqueue.add(g)

// 3. If stack needs to grow, it happens automatically
// 4. Scheduling is handled by Go runtime
// 5. No kernel involvement for scheduling!

Key Differences:

1. System Calls:
• C++: Each thread creation = 1 system call
• Go: No system calls for goroutine creation

2. Memory Usage:
• C++: ~8MB per thread
• Go: ~2KB per goroutine

3. Scheduling:
• C++: OS scheduler (expensive context switches)
• Go: Runtime scheduler (cheap context switches)

4. Resource Limits:
• C++: Limited by OS thread limits
• Go: Limited only by available memory

5. Stack Management:
• C++: Fixed stack size
• Go: Dynamic, grows/shrinks as needed

Scheduling

• OS Thread:
• Scheduled by the OS kernel
• Context switching is expensive (must save/restore large amount of state)
• Scheduling decisions involve system calls

• Goroutine:
• Scheduled by Go runtime
• Context switching is cheap (minimal state to save/restore)
• No system calls needed for scheduling
• Uses work-stealing scheduler

Go Scheduler (GMP Model) In-Depth

What is the GMP Model?

• G: Goroutine

• M: OS Thread (Machine)

• P: Processor (Logical CPU)

Components in Detail

type g struct {
stack       stack           // offset known to runtime/cgo
stackguard0 uintptr         // offset known to liblink
stackguard1 uintptr         // offset known to liblink
_panic       *_panic        // innermost panic - offset known to liblink
_defer       *_defer        // innermost defer
m            *m             // current m; offset known to arm liblink
sched        gobuf
syscallsp    uintptr        // if status==Gsyscall, syscallsp = sched.sp to use during gc
syscallpc    uintptr        // if status==Gsyscall, syscallpc = sched.pc to use during gc
stktopsp     uintptr        // expected sp at top of stack, to check in traceback
param        unsafe.Pointer // passed parameter on wakeup
atomicstatus uint32
stackLock    uint32         // sigprof/scang lock; TODO: fold in to atomicstatus
goid         int64
// ... more fields
}

type m struct {
    g0      *g       // goroutine with scheduling stack
    mstartfn func()
    curg    *g       // current running goroutine
    p       puintptr // attached p for executing go code (nil if not executing go code)
    nextp   puintptr
    oldp    puintptr
    id      int64
    // ... more fields
}

type p struct {
    id          int32
    status      uint32     // one of pidle/prunning/...
    link        puintptr
    schedtick   uint32     // incremented on every scheduler call
    syscalltick uint32     // incremented on every system call
    sysmontick  sysmontick // last tick observed by sysmon
    m           muintptr   // back-link to associated m (nil if idle)
    mcache      *mcache
    // ... more fields
}

How Does the Scheduler Work?

1. Initial Setup

func main() {
    // Go runtime starts with:
    GOMAXPROCS = runtime.NumCPU() // Default P count
    M1 = CreateOSThread()         // Main thread
    P1 = CreateProcessor()        // Main processor
    G1 = CreateGoroutine(main)    // Main goroutine
}

2. Goroutine Creation and Scheduling

// When you create a new goroutine
go func() {
    // 1. Create new G structure
    newg := newproc(fn)

    // 2. Add to P's local queue or global queue
    runqput(p, newg, true)
}

3. Work Stealing Algorithm

func findRunnable() *g {
    // 1. Check local run queue
    if g := runqget(p); g != nil {
        return g
    }

    // 2. Check global queue
    if g := globrunqget(p); g != nil {
        return g
    }

    // 3. Check other P's queues (steal)
    for i := 0; i < len(allp); i++ {
        if g := runqsteal(p, allp[i]); g != nil {
            return g
        }
    }

    // 4. Check network/timer/GC work
    if g := findrunnable(); g != nil {
        return g
    }
}

Best Practices

• Right Number of Ps

// Generally good to match CPU count
runtime.GOMAXPROCS(runtime.NumCPU())

• Avoid Goroutine Leaks

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            return // Always have exit condition
        default:
            // work
        }
    }
}

• Monitor Scheduler Health

func monitorScheduler() {
    for range time.Tick(time.Second) {
        fmt.Printf("Goroutines: %d\n", runtime.NumGoroutine())
    }
}