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.

Key differences:

• Goroutines start with 2KB stack (grows dynamically); threads start with 1-8MB (fixed).
• Goroutines are scheduled by Go runtime (cooperative); threads are scheduled by OS (preemptive).
• Creating a goroutine costs ~2µs; creating a thread costs ~10-100µs.
• Goroutines share address space; threads may have separate or shared spaces.
• Millions of goroutines vs thousands of threads is practical.

Implementation:

1// Goroutine — cheap and easy
2go func() {
3    fmt.Println("Running concurrently")
4}()
5
6// Multiple goroutines for fan-out pattern
7var wg sync.WaitGroup
8for i := 0; i < 1000; i++ {
9    wg.Add(1)
10    go func(id int) {
11        defer wg.Done()
12        processItem(id)
13    }(i)
14}
15wg.Wait()

Scheduling behavior:

• Goroutines are multiplexed onto OS threads via the GMP model.
• When a goroutine blocks (I/O, channel), the scheduler switches to another.
• Go scheduler uses work stealing across P processors.

When to use goroutines:

• Concurrent I/O (HTTP requests, file operations, database queries).
• Background tasks (cleanup, periodic jobs).
• Fan-out/fan-in patterns (parallel processing).

When to use threads:

• Interfacing with C code via cgo.
• When you need thread-local storage.
• Very long-running computations that shouldn't be interrupted.

Common mistakes:

• Assuming goroutines are parallel (they're concurrent; parallelism depends on GOMAXPROCS).
• Not synchronizing goroutine completion (using sync.WaitGroup or channels).
• Creating goroutines in loops without passing loop variables (closure captures by reference).
• Using runtime.LockOSThread() without understanding the performance implications.
• Over-creating goroutines without backpressure (use buffered channels or worker pools).