Go: What is the difference between goroutine and thread?

Goroutine — lightweight concurrency primitive. Thread — OS-level execution unit.

Key differences:

• Stack: goroutine 2KB (dynamic) vs thread 1-8MB (fixed).
• Scheduling: Go runtime (cooperative) vs OS (preemptive).
• Creation cost: goroutine ~2µs vs thread ~10-100µs.
• Capacity: millions of goroutines vs thousands of threads.

1// Goroutine-based concurrent processing
2func processConcurrently(items []Item) []Result {
3    results := make([]Result, len(items))
4    var wg sync.WaitGroup
5    
6    for i, item := range items {
7        wg.Add(1)
8        go func(i int, item Item) {
9            defer wg.Done()
10            results[i] = process(item)
11        }(i, item)
12    }
13    wg.Wait()
14    return results
15}

When to use goroutines:

• I/O-bound concurrency.
• Background tasks.
• Fan-out/fan-in patterns.

When to use threads:

• Cgo interop.
• Thread-local storage.
• Long-running CPU-bound tasks.

Common mistakes:

• Not synchronizing completion.
• Closure variable capture in loops.
• Assuming goroutines are always parallel.
• Creating too many without backpressure.
• Using runtime.LockOSThread() unnecessarily.