Zjistěte, jak goroutiny a kanály umožňují efektivní souběžnost ve vašich programech Go.

Souběžnost je zásadním aspektem vývoje moderního softwaru, protože umožňuje programům efektivně zvládat více úkolů současně. Můžete psát programy, které provádějí různé operace vedoucí ke zlepšení výkonu, odezvy a využití zdrojů.

Souběžnost je jednou z funkcí odpovědných za rychlé přijetí Go. Vestavěná podpora souběžného programování Go je považována za přímou a zároveň pomáhá vyhnout se běžným nástrahám, jako jsou závodní podmínky a uváznutí.

Souběžnost v Go

Go poskytuje robustní podporu pro souběžnost prostřednictvím různých mechanismů, které jsou všechny dostupné ve standardní knihovně a řetězci nástrojů. Přejít na programy dosáhnout souběžnosti prostřednictvím goroutin a kanálů.

Goroutines jsou lehké, nezávisle provádějící funkce, které běží souběžně s jinými goroutiny ve stejném adresním prostoru. Goroutiny umožňují souběžný průběh více úkolů bez explicitní správy vláken. Goroutines jsou lehčí než vlákna operačního systému a Go dokáže efektivně spouštět tisíce nebo dokonce miliony goroutin současně.

instagram viewer

Kanály jsou komunikačním mechanismem pro koordinaci a sdílení dat mezi gorutiny. Kanál je typovaný kanál, který umožňuje gorutinům odesílat a přijímat hodnoty. Kanály zajišťují synchronizaci, aby bylo zajištěno bezpečné sdílení dat mezi goroutinemi a zároveň předcházelo závodům a dalším běžným problémům souběžnosti.

Kombinací goroutin a kanálů poskytuje Go výkonný a přímočarý souběžný model, který zjednodušuje vývoj souběžných programů při zachování bezpečnosti a efektivity. Tyto mechanismy vám umožňují snadné použití vícejádrové procesory a vytvářet vysoce škálovatelné a citlivé aplikace.

Jak používat goroutiny pro souběžné spouštění kódu

Runtime Go spravuje goroutiny. Goroutines mají svůj zásobník, což jim umožňuje mít nízkou velikost s počáteční velikostí zásobníku několik kilobajtů.

Goroutines jsou multiplexovány do několika vláken OS pomocí běhového prostředí Go. Runtime plánovač Go je naplánuje do dostupných vláken efektivním rozložením pracovní zátěže, což umožňuje souběžné spouštění více goroutin na menším počtu vláken OS.

Vytváření goroutin je jednoduché. Budete používat jít klíčové slovo následované voláním funkce pro deklaraci goroutin.

funchlavní() {
jít funkce1() // Vytvořte a spusťte goroutinu pro funkci1
jít funkce2() // Vytvořte a spusťte goroutine pro funkci2
// ...
}


funcfunkce1() {
// Kód pro funkci1
}
funcfunkce2() {
// Kód pro funkci2
}

Když program vyvolá funkce1() a funkce2() s jít běhové prostředí Go spustí funkce souběžně jako gorutiny.

Zde je příklad použití goroutinu, který tiskne text do konzole:

balík hlavní
import (
"fmt"
"čas"
)


functisknoutText() {
pro já:= 1; i <= 5; i++ {
 fmt. Println("Tisk textu", i)
 čas. Spát(1 * čas. Druhý)
 }
}


funchlavní() {
jít printText() // Spuštění goroutine pro souběžné spuštění funkce printText


// Proveďte další úkoly v hlavní goroutině
pro já:= 1; i <= 5; i++ {
 fmt. Println("Provádění jiných úkolů", i)
 čas. Spát(500 * čas. milisekundy)
 }
// Počkejte, až goroutine skončí
 čas. Spát(6 * čas. Druhý)
}

The tisknoutText funkce opakovaně tiskne nějaký text do konzole s a pro smyčka, která se spustí pětkrát po jednosekundové prodlevě mezi každým příkazem s časový balíček.

The hlavní funkce spustí goroutinu voláním jít tisknoutText, která spouští tisknoutText funguje jako samostatná souběžná gorutina, která umožňuje, aby se funkce spouštěla ​​souběžně se zbytkem kódu v hlavní funkce.

A konečně, abyste zajistili, že program neukončí dříve než tisknoutText goroutine skončí, čas. Spát funkce pozastaví hlavní rutinu na šest sekund. Ve scénářích reálného světa byste ke koordinaci provádění goroutin používali mechanismy synchronizace, jako jsou kanály nebo čekající skupiny.

Použití kanálů pro komunikaci a synchronizaci

Goroutines mají vestavěnou podporu pro komunikaci a synchronizaci prostřednictvím kanálů, díky čemuž je psaní souběžné kód jednodušší než tradiční vlákna, která často vyžadují manuální synchronizační mechanismy, jako jsou zámky a semafory.

Kanály si můžete představit jako kanály pro tok dat mezi gorutinami. Jedna rutina může poslat hodnotu do kanálu a jiná může tuto hodnotu z kanálu přijmout. Tento mechanismus zajišťuje, že výměna dat je bezpečná a synchronizovaná.

Budete používat odesílat a přijímat data prostřednictvím kanálů.

Zde je příklad demonstrující základní použití kanálů pro komunikaci mezi dvěma goroutiny:

funchlavní() {
// Vytvoří kanál bez vyrovnávací paměti typu string
 ch := udělat(chantětiva)
// Goroutine 1: Odešle zprávu do kanálu
jítfunc() {
 ch "Ahoj, Channel!"
 }()
// Goroutine 2: Přijme zprávu z kanálu
 msg :=  fmt. Println (zpráva) // Výstup: Ahoj, kanále!
}

Kanál v hlavní funkce je pojmenovaný kanál bez vyrovnávací paměti ch vytvořený s udělat() funkce. První gorutina pošle zprávu "Hello, Channel!" do kanálu pomocí operátor a druhý goroutine přijme zprávu z kanálu pomocí stejného operátora. Konečně, hlavní funkce vytiskne přijatou zprávu do konzole.

Můžete definovat typované kanály. Typ kanálu určíte při vytváření. Zde je příklad, který ukazuje použití různých typů kanálů:

funchlavní() {
// Kanál bez vyrovnávací paměti
 ch1 := udělat(chanint)
// Kanál s vyrovnávací pamětí s kapacitou 3
 ch2 := udělat(chantětiva, 3)


// Odesílání a příjem hodnot z kanálů
 ch1 42// Odešle hodnotu do ch1
 hodnota1 := // Přijme hodnotu z ch1
 ch2 "Ahoj"// Odešle hodnotu do ch2
 hodnota2 := // Přijme hodnotu z ch2
}

The hlavní funkce vytváří dva kanály: ch1 je celočíselný kanál bez vyrovnávací paměti, zatímco ch2 je vyrovnávací řetězcový kanál s kapacitou 3. Hodnoty do az těchto kanálů můžete odesílat a přijímat pomocí operátor (hodnoty musí být zadaného typu).

Kanály můžete použít jako synchronizační mechanismy pro koordinaci provádění goroutin tím, že využijete blokující povahu operací s kanály.

funchlavní() {
 ch := udělat(chanbool)
jítfunc() {
 fmt. Println("Goroutine 1")
 ch skutečný// Dokončení signálu
 }()


jítfunc() {
 // Počkejte na signál dokončení z Goroutine 1
 fmt. Println("Goroutine 2")
 }()
 // Počkejte na signál dokončení z Goroutine 2
 fmt. Println("Hlavní goroutine")
}

The ch kanál je booleovský. Dvě goroutiny běží souběžně v hlavní funkce. Goroutine 1 signalizuje dokončení odesláním a skutečný hodnotu do kanálu ch. Goroutine 2 čeká na signál dokončení přijetím hodnoty z kanálu. Nakonec hlavní goroutina čeká na signál dokončení od goroutiny dva.

Můžete vytvářet webové aplikace v Go With Gin

V Go with Gin můžete vytvářet vysoce výkonné webové aplikace a zároveň využívat funkce souběžnosti Go.

Gin můžete použít k efektivnímu zpracování směrování HTTP a middlewaru. Využijte vestavěnou podporu souběžnosti Go tím, že použijete goroutiny a kanály pro úlohy, jako jsou databázové dotazy, volání API nebo jiné blokovací operace.