Conas a fheidhmíonn sceidealóir an runtime Go?

Question

Accepted Answer

Áirítear i runtime Go **sceidealóir** a dhéanann illíonadh ar go leor goroutines ar líon beag snáitheanna OS. Is é an **sceidealú M:N** seo (M goroutines ar N snáitheanna OS) a dhéanann goroutines chomh saor agus a dhéanann comhthreanga Go chomh inscálaithe. Tuigint air a thugann míniú ar fheidhmíochta na goroutines.

## An tsamhail G-M-P

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

Mapálfaidh an runtime go leor goroutines (G) ar snáitheanna OS (M) trí phróiseálaithe loighciúla (P). Tá P amháin in aghaidh chroí CPU de réir réamhshocrú (`GOMAXPROCS`), gach ceann le scuaine goroutines atá réidh rith.

## Conas a bhaint amach comhthreanga saor agus inscálaithe

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

Toisc go raibh an sceidealóir ag bainistiú comhthreanga na goroutines i spás úsáideora (ní athraíonn snáithe ag leibhéal kernel), agus go bhfuil stacs bitíní beag ag goroutines, is féidir leat i bhfad níos mó goroutines ná snáitheanna OS a rith, go saor.

## Iompar ábhartha an sceidealóra

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

Coimeádann **stoladh oibre** croíanna gníomhach, **ath-ghabhálach** a bhreantaíonn goroutine amháin ó chrann a chore, agus go criticiúil, nuair a bhreantaíonn goroutine (ar chainéal nó syscall), leanann an sceidealóir ar aghaidh ag rith goroutines eile in áit an tsnaí a dhó.

## GOMAXPROCS

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

## Cén fáth nach bhfuil goroutines saor, áfach

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

## Cén fáth is dóigh leis

Is é an sceidealóir Go an t-inneall taobh thiar de shaorfhad agus inscálaitheacht a réimircíonn goroutines — tuigint ar a **shamhail M:N** (go leor goroutines ar bhreall snáitheanna OS trí dhearadh G-M-P) a mhíníonn *cén fáth* ar féidir le Go milliúin goroutines a rith nuair a bhríonn snáitheanna OS an bhreis i na míle, agus *cén fáth* ar bhí a chomhthreanga chomh héifeachtach (athrú i spás úsáideora in ionad athraíocha context OS costasacha, fíor-chomhpháirtíochta trasna croí trí GOMAXPROCS).

Is í an bhainistiú cliste ar bhreantú (parking na goroutines breantaithe ar chainéal, pas P ar syscalls ionas nach ndó snáitheanna), an **stoladh oibre** do bhreisiú ualach, agus **ath-ghabhálach** (ó 1.14 ar aghaidh) chun gort a chosc is iad ar dhéanann comhthreanga Go daingean faoi ualach fíoraigneata.

Cé go raibh tú i bhfad gníomhach ar an sceidealóir go díreach, tuigint air a dhoimhníonn do thuiscint ar fheidhmíochta goroutine, a mhíníonn iompar (cén fáin nach ndó breantú snáitheanna, cén fáin ar féidir leat an oiread goroutines a bhronnadh), agus thuilleanns a dhéanann cinntí ar nós comhthreanga a cheangal.

Is ábhar ardleibhéal é seo a thaisprionn fíor-dhoimhneacht eolais Go runtime agus tá sé luachmhar i n-agallaimh ardleibhéal.