Go: What is the difference between go routine and thread?

Goroutine — lightweight, managed by Go runtime. Thread — OS-level execution unit managed by the operating system.

Memory footprint:

• Goroutine starts with a 2KB stack that grows/shrinks dynamically as needed.
• OS thread allocates 1-8MB upfront and cannot resize.
• This means you can spawn millions of goroutines but only thousands of threads.

Scheduling:

• Goroutines are scheduled by the Go runtime (cooperative scheduling at function calls and channel operations).
• Threads are scheduled by the OS kernel (preemptive scheduling based on time slices).
• Go scheduler multiplexes goroutines onto a small pool of OS threads via the GMP model.

Creation and teardown:

• Creating a goroutine is ~2x the cost of a function call (negligible).
• Creating a thread involves a system call and much heavier allocation.

1// Spawning thousands of goroutines is trivial
2for i := 0; i < 1000000; i++ {
3    go func(id int) {
4        // Each goroutine uses ~2KB initially
5        runtime.Gosched() // yield to scheduler
6    }(i)
7}

When to use goroutines vs threads:

• Use goroutines for concurrent I/O, background tasks, fan-out/fan-in patterns.
• Use OS threads only when interfacing with C libraries (cgo) or when you need thread-local storage.

Common mistakes:

• Creating OS threads manually via runtime.LockOSThread() without understanding the cost.
• Not using sync.WaitGroup or channels to coordinate goroutine completion, leading to data races.
• Assuming goroutines are parallel — they are concurrent and only parallel on multi-core with GOMAXPROCS > 1.
• Forgetting that goroutines share the same address space, so shared mutable state requires synchronization.