Go: What is the difference between goroutine and thread?

Goroutine — lightweight concurrency primitive managed by Go runtime. Thread — OS-level execution unit with dedicated kernel resources.

Memory efficiency:

• Goroutines: start at 2KB stack, grow/shrink dynamically (up to 1GB).
• Threads: fixed 1-8MB stack per thread.
• Practical limit: millions of goroutines vs thousands of threads.

Scheduling:

• Goroutines: cooperative scheduling at specific points (channel ops, function calls, runtime.Gosched()).
• Threads: preemptive scheduling by OS (time-slice based).
• Go scheduler: work-stealing across P processors.

Creation cost:

• Goroutine: ~2µs, ~2KB memory.
• Thread: ~10-100µs, ~1-8MB memory.
• Goroutine creation is ~50-500x cheaper.

1// Efficient concurrent processing
2func processItems(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    
14    wg.Wait()
15    return results
16}

When to use goroutines:

• I/O-bound concurrency (HTTP, database, file operations).
• Background tasks (cleanup, periodic jobs).
• Fan-out/fan-in patterns.
• Event-driven architectures.

When to use threads:

• Cgo interop (calling C code).
• Thread-local storage requirements.
• Long-running CPU-bound tasks that shouldn't yield.

Common mistakes:

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