Questions
8 of 10
1Explain the fan-out and fan-in concurrency pattern with a practical example.
2How does the select statement work with multiple channels, including a default case?
3How does Go's GMP scheduler work and how does it affect concurrency design?
4Describe how you would approach a Go service that needs to process Kafka events with exactly-once semantics.
5What is a goroutine leak and how do you detect and prevent one?
6When should you use sync.Mutex vs channels for shared state?
7How would you implement a distributed task queue in Go without using an external framework?
8What is a goroutine, and how does it differ from an OS thread?
9What is the difference between a buffered and unbuffered channel?
10Design a worker pool for processing 100,000 jobs with back-pressure and graceful shutdown.
golanggolang
Basics
Data Structures
Interfaces and Types
Concurrency
Memory Management
Error Handling
Packages and Modules
Web and API Development
Databases and Storage
Testing
DevOps and Deployment
Standard Library
08 / 10

What is a goroutine, and how does it differ from an OS thread?

Goroutines are lightweight user-space threads managed by the Go runtime, starting at ~2KB of stack and multiplexed onto a small pool of OS threads through the M:N scheduler.

Goroutines vs OS threads
  1. 1

    OS thread stack: 1-8MB fixed. Goroutine stack: starts at 2KB, grows and shrinks dynamically up to 1GB

  2. 2

    Context switch: OS thread switch requires kernel mode transition (~1μs). Goroutine switch is in user space (~100ns)

  3. 3

    Creation cost: spawning an OS thread takes ~10-100μs. Launching a goroutine takes ~1μs

  4. 4

    Scheduling: OS scheduler is preemptive and unaware of Go semantics. Go scheduler is cooperative with preemption at safe points

  5. 5

    Scale: practical limit for OS threads is ~10,000. Go programs routinely run 100,000+ goroutines

Goroutine basics