Go runtime scheduler எவ்வாறு வேலை செய்கிறது?

Question

Accepted Answer

Go runtime ஆனது பல goroutines-ஐ சிறிய எண்ணிக்கையிலான OS threads-இல் multiplex செய்யும் ஒரு **scheduler**-ஐ உள்ளடக்கியுள்ளது. இந்த **M:N scheduling** (N OS threads-இல் M goroutines) ஆனதே goroutines-ஐ மிகவும் மலிவாகவும், Go-வின் concurrency-ஐ மிகவும் scalable-ஆகவும் ஆக்குகிறது. அதைப் புரிந்துகொள்வது goroutine performance-ஐ விளக்குகிறது.

## G-M-P model

```text
G (Goroutine) — your concurrent task (lightweight, ~2KB stack to start)
M (Machine)   — an OS thread (the actual thread the OS schedules)
P (Processor) — a logical processor / scheduling context; holds a queue of runnable Gs
                (the number of P's = GOMAXPROCS, default = number of CPU cores)

The scheduler runs G's on M's, coordinated through P's:
  Each P has a local run queue of goroutines; an M must hold a P to run G's.
```

runtime ஆனது logical processors (P) வழியாக பல goroutines (G)-ஐ OS threads (M)-இல் வரைபடமாக்குகிறது. இயல்பாக ஒரு CPU core-க்கு ஒரு P உள்ளது (`GOMAXPROCS`), ஒவ்வொன்றிலும் ஓட தயாராக உள்ள goroutines-இன் ஒரு queue இருக்கிறது.

## மலிவான, scalable concurrency-ஐ எவ்வாறு அடைகிறது

```text
✓ Creating a goroutine is cheap (tiny stack, runtime-managed) → millions feasible
✓ Switching goroutines happens in USER space (runtime), not via expensive OS
  context switches → far lighter than switching OS threads
✓ With P = CPU cores, Go runs goroutines truly in parallel across cores
```

scheduler ஆனது goroutine switching-ஐ user space-இல் (kernel-level thread switches அல்ல) கையாள்வதால், மேலும் goroutines-க்கு சிறிய stacks இருப்பதால், OS threads-ஐ விட பெருமளவில் அதிக goroutines-ஐ மலிவாக இயக்க முடியும்.

## முக்கிய scheduler behaviors

```text
✓ Work stealing — an idle P STEALS goroutines from a busy P's queue → load balancing
✓ Cooperative + preemptive — goroutines yield at function calls/channel ops/blocking;
  since Go 1.14, the scheduler can also PREEMPT long-running goroutines (no starvation)
✓ Blocking handled smartly:
   - A goroutine blocked on a CHANNEL/sync → parked, the M runs other goroutines (no thread wasted)
   - A goroutine blocked on a SYSCALL (e.g. file I/O) → the M blocks, but the P is
     handed to ANOTHER M so other goroutines keep running
```

**Work stealing** ஆனது cores-ஐ பணியில் வைத்திருக்கிறது, **preemption** ஆனது ஒரு goroutine ஒரு core-ஐ ஆக்கிரமிப்பதைத் தடுக்கிறது, மேலும் முக்கியமாக, ஒரு goroutine block ஆகும்போது (channel அல்லது syscall-இல்), scheduler ஆனது thread-ஐ வீணடிப்பதற்குப் பதிலாக மற்ற goroutines-ஐ இயங்க வைக்கிறது.

## GOMAXPROCS

```go
runtime.GOMAXPROCS(4)    // limit to 4 OS threads running Go code simultaneously
// default = number of CPU cores; rarely needs changing
```

## ஆனாலும் goroutines இலவசம் அல்ல

```text
Goroutines are cheap but not zero-cost — millions still use memory, and excessive
goroutines add scheduling overhead. Bound concurrency (worker pools) for heavy loads.
```

## இது ஏன் முக்கியம்

Go scheduler ஆனது goroutines-இன் குறிப்பிடத்தக்க மலிவுத்தன்மை மற்றும் scalability-க்குப் பின்னால் உள்ள இயந்திரமாகும் — அதன் **M:N model**-ஐ (G-M-P design வழியாக சில OS threads-இல் பல goroutines) புரிந்துகொள்வது, OS threads ஆயிரக்கணக்கில் max ஆகும்போது Go ஏன் மில்லியன் கணக்கான goroutines-ஐ இயக்க முடியும் என்பதையும், அதன் concurrency ஏன் மிகவும் திறமையானது (costly OS context switches-க்குப் பதிலாக user-space switching, GOMAXPROCS வழியாக cores முழுவதும் உண்மையான parallelism) என்பதையும் விளக்குகிறது.

blocking-இன் புத்திசாலித்தனமான கையாளுதல் (channel-block ஆன goroutines-ஐ park செய்தல், syscalls-இல் P-ஐ ஒப்படைத்தல், இதனால் threads வீணாகாது), load balancing-க்கான **work stealing**, மற்றும் starvation-ஐ தடுக்க **preemption** (1.14 முதல்) ஆகியவையே Go-வின் concurrency-ஐ உண்மையான workloads-இன் கீழ் robust ஆக்குகின்றன.

நீங்கள் scheduler-உடன் நேரடியாக அரிதாகவே தொடர்புகொள்கிறீர்கள் என்றாலும், அதைப் புரிந்துகொள்வது goroutine performance-க்கான உங்கள் உள்ளுணர்வை ஆழப்படுத்துகிறது, behaviors-ஐ விளக்குகிறது (blocking ஏன் threads-ஐ வீணடிப்பதில்லை, ஏன் இவ்வளவு goroutines-ஐ துவக்க முடியும்), மற்றும் concurrency-ஐ வரம்பிடுதல் போன்ற முடிவுகளை வழிநடத்துகிறது.

இது Go runtime அறிவின் உண்மையான ஆழத்தை வெளிப்படுத்தும் ஒரு மேம்பட்ட தலைப்பாகும் மற்றும் senior interviews-இல் மதிக்கப்படுகிறது.