Πώς λειτουργεί ο scheduler του Go runtime;

Question

Accepted Answer

Το Go runtime περιλαμβάνει έναν **scheduler** που πολυπλέκει πολλές goroutines σε έναν μικρό αριθμό OS threads. Αυτή η **M:N scheduling** (M goroutines σε N OS threads) είναι αυτό που κάνει τις goroutines τόσο φτηνές και την concurrency του Go τόσο scalable. Η κατανόησή του εξηγεί την απόδοση των goroutines.

## The 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 αντιστοιχεί πολλές goroutines (G) σε OS threads (M) μέσω λογικών processors (P). Υπάρχει ένα P ανά πυρήνα CPU από προεπιλογή (`GOMAXPROCS`), καθένα με μια ουρά goroutines έτοιμων να εκτελεστούν.

## Πώς επιτυγχάνει φτηνή και 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 χειρίζεται την εναλλαγή goroutines στο user space (όχι kernel-level thread switches), και οι goroutines έχουν πολύ μικρές στοίβες, μπορείτε να εκτελέσετε πολύ περισσότερες goroutines από OS threads, με φτηνό κόστος.

## Βασικές συμπεριφορές του scheduler

```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 μπλοκάρεται (σε ένα channel ή syscall), ο scheduler διατηρεί άλλες goroutines σε εκτέλεση αντί να αχρησιμοποιήσει το thread.

## 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.
```

## Γιατί έχει σημασία

Ο scheduler του Go είναι ο κινητήρας πίσω από την αξιοσημείωτη φτηνότητα και scalability των goroutines — η κατανόησή του **M:N model** (πολλές goroutines σε λίγα OS threads μέσω του G-M-P design) εξηγεί *γιατί* το Go μπορεί να εκτελέσει εκατομμύρια goroutines όταν τα OS threads φτάνουν το όριό τους στις χιλιάδες, και *γιατί* η concurrency του είναι τόσο αποδοτική (user-space switching αντί δαπανηρών OS context switches, πραγματικός parallelism σε cores μέσω GOMAXPROCS).

Το έξυπνο χειρισμό του blocking (parking channel-blocked goroutines, handoff P σε syscalls ώστε τα threads να μην αχρησιμοποιούνται), το **work stealing** για load balancing, και η **preemption** (από την έκδοση 1.14) για την αποτροπή starvation είναι αυτό που κάνει τη concurrency του Go ισχυρή υπό πραγματικά workloads.

Αν και σπάνια αλληλεπιδράτε με τον scheduler άμεσα, η κατανόησή του εμβαθύνει την ανθρώπινη διαίσθησή σας για την απόδοση των goroutines, εξηγεί συμπεριφορές (γιατί το blocking δεν αχρησιμοποιεί threads, γιατί μπορείτε να δημιουργήσετε τόσες πολλές goroutines), και ενημερώνει αποφάσεις όπως το bounding της concurrency.

Είναι ένα ανώτερο θέμα που καταδεικνύει γνήσια βάθος γνώσης του Go runtime και εκτιμάται σε συνεντεύξεις για senior θέσεις.