Bevezetés a párhuzamosságba a Go-ban

A párhuzamosság a modern szoftverfejlesztés kulcsfontosságú eleme, mivel lehetővé teszi a programok számára, hogy egyszerre több feladatot is hatékonyan kezeljenek. Olyan programokat írhat, amelyek különféle műveleteket hajtanak végre, amelyek javítják a teljesítményt, a válaszkészséget és az erőforrás-kihasználást.

A párhuzamosság az egyik olyan funkció, amely felelős a Go gyors elfogadásáért. A Go beépített támogatása a párhuzamos programozáshoz egyszerűnek tekinthető, miközben segít elkerülni az olyan gyakori buktatókat, mint a versenykörülmények és a holtpontok.

Egyidejűség a Go-ban

A Go erőteljes támogatást nyújt a párhuzamossághoz különféle mechanizmusokon keresztül, amelyek mindegyike elérhető a szabványos könyvtárában és eszközláncában. Menj programok gorutinokon és csatornákon keresztül érje el az egyidejűséget.

A gorutinok könnyű súlyú, egymástól függetlenül végrehajtó függvények, amelyek más gorutinokkal párhuzamosan futnak ugyanazon a címtéren belül. A Goroutines lehetővé teszi több feladat egyidejű előrehaladását explicit szálkezelés nélkül. A gorutinok könnyebbek, mint az operációs rendszer szálai, és a Go több ezer vagy akár millió gorutin futtatására képes egyszerre.

A csatornák a gorutinok közötti koordináció és adatmegosztás kommunikációs mechanizmusai. A csatorna egy típusos csatorna, amely lehetővé teszi a gorutinok számára értékek küldését és fogadását. A csatornák szinkronizálást biztosítanak a biztonságos adatmegosztás érdekében a gorutinok között, miközben megakadályozzák a versenykörülményeket és más gyakori egyidejűségi problémákat.

A gorutinok és csatornák kombinálásával a Go erőteljes és egyértelmű párhuzamossági modellt biztosít, amely leegyszerűsíti a párhuzamos programok fejlesztését, miközben megőrzi a biztonságot és a hatékonyságot. Ezek a mechanizmusok lehetővé teszik a könnyű használatot többmagos processzorok és nagyon skálázható és érzékeny alkalmazásokat készíthet.

A Goroutines használata párhuzamos kódvégrehajtáshoz

A Go futtatókörnyezet kezeli a gorutinokat. A Goroutine-oknak megvan a saját veremük, ami lehetővé teszi számukra, hogy néhány kilobájt kezdeti veremmérettel kis súlyú lábnyomot kapjanak.

A gorutinokat több operációs rendszer-szálra multiplexeli a Go futási környezet. A Go futásidejű ütemező a munkaterhelés hatékony elosztásával ütemezi őket az elérhető szálakra, lehetővé téve több gorutin egyidejű végrehajtását kevesebb operációs rendszer-szálon.

A gorutinok létrehozása egyszerű. Használja a megy kulcsszó, majd egy függvényhívás a gorutinok deklarálásához.

funcfő-() {
megy függvény1() // Gorutine létrehozása és végrehajtása a function1 számára
megy függvény2() // Gorutine létrehozása és végrehajtása a function2 számára
// ...
}
funcfunkció1() {
// Funkció1 kódja
}
funcfunkció2() {
// Funkció2 kódja
}

Amikor a program meghívja függvény1() és függvény2() a... val megy kulcsszó, a Go futtatókörnyezet egyidejűleg hajtja végre a függvényeket gorutinként.

Íme egy példa egy gorutin használatára, amely szöveget nyomtat a konzolra:

csomag fő-
import (
"fmt"
"idő"
)
funcprintText() {
számára én := 1; én <= 5; i++ {
 fmt. Println("Szöveg nyomtatása", i)
 idő. Alvás(1 * idő. Második)
 }
}
funcfő-() {
megy printText() // Gorutin indítása a printText függvény egyidejű végrehajtásához
// Egyéb feladatok végrehajtása a fő gorutinban
számára én := 1; én <= 5; i++ {
 fmt. Println("Egyéb feladatok ellátása", i)
 idő. Alvás(500 * idő. Miliszekundum)
 }
// Várd meg, amíg a gorutin véget ér
 idő. Alvás(6 * idő. Második)
}

A printText függvény ismételten kiír szöveget a konzolra a számára ciklus, amely ötször fut le az egyes utasítások közötti egy másodperces késleltetést követően az időcsomagot.

A fő- függvény hívásával gorutint indít menj printText, amely elindítja a printText különálló párhuzamos gorutinként működik, amely lehetővé teszi a függvénynek a kód többi részével egyidejű végrehajtását. fő- funkció.

Végül annak biztosítása érdekében, hogy a program ne lépjen ki a printText gorutin befejezi, a idő. Alvás funkció hat másodpercre szünetelteti a fő gorutint. Valós forgatókönyvekben szinkronizálási mechanizmusokat, például csatornákat vagy várakozási csoportokat használ a gorutinok végrehajtásának koordinálására.

Csatornák használata kommunikációhoz és szinkronizáláshoz

A Goroutines beépített támogatással rendelkezik a kommunikációhoz és a csatornákon keresztüli szinkronizáláshoz, így az írás párhuzamos kód egyszerűbb, mint a hagyományos szálak, amelyek gyakran kézi szinkronizálási mechanizmusokat igényelnek, például zárakat és szemaforok.

A csatornákat a gorutinok közötti adatáramlás folyamatának tekintheti. Egy gorutin küldhet egy értéket a csatornába, egy másik gorutin pedig fogadhatja ezt az értéket a csatornától. Ez a mechanizmus biztosítja az adatcsere biztonságosságát és szinkronizálását.

Használja a operátort, hogy adatokat küldjön és fogadjon csatornákon keresztül.

Íme egy példa, amely bemutatja a csatornák alapvető használatát két gorutin közötti kommunikációhoz:

funcfő-() {
// Hozzon létre egy nem pufferelt csatornát karakterlánc típusú
 ch := készítsenek(chanhúr)
// 1. Gorutine: Üzenetet küld a csatornába
megyfunc() {
 ch – Helló, Csatorna!
 }()
// Goroutine 2: Üzenet fogadása a csatornától
 msg :=  fmt. Println (üzenet) // Kimenet: Hello, Channel!
}

A csatorna a fő- függvény egy puffereletlen nevű csatorna ch a gyártmány() funkció. Az első gorutin a "Hello, Channel!" üzenetet küldi. segítségével a csatornába operátor, és a második gorutin ugyanazt az operátort használja a csatornától. Végül a fő- funkció kinyomtatja a kapott üzenetet a konzolra.

Megadhat beírt csatornákat. A csatorna típusát a létrehozáskor kell megadnia. Íme egy példa, amely bemutatja a különböző csatornatípusok használatát:

funcfő-() {
// Puffereletlen csatorna
 ch1 := készítsenek(chanint)
// Pufferelt csatorna 3 kapacitással
 ch2 := készítsenek(chanhúr, 3)
// Értékek küldése és fogadása csatornákról
 ch1 42// Érték küldése a ch1-be
 érték1 := // Érték fogadása a ch1-ből
 ch2 "Helló"// Érték küldése a ch2-be
 érték2 := // Érték fogadása a ch2-ből
}

A fő- funkció két csatornát hoz létre: ch1 egy nem pufferelt egész csatorna, míg ch2 egy pufferelt karakterlánc csatorna, amelynek kapacitása 3. Ezekre a csatornákra és onnan értékeket küldhet és fogadhat a segítségével operátort (az értékeknek a megadott típusúaknak kell lenniük).

A csatornákat szinkronizálási mechanizmusként használhatja a gorutin végrehajtásának koordinálásához, kihasználva a csatornaműveletek blokkoló jellegét.

funcfő-() {
 ch := készítsenek(chanbool)
megyfunc() {
 fmt. Println("Goroutine 1")
 ch igaz// A jel befejezése
 }()
megyfunc() {
 // Várja meg a Goroutine 1 befejezési jelét
 fmt. Println("Goroutine 2")
 }()
 // Várja meg a Goroutine 2 befejezési jelét
 fmt. Println("Fő gorutin")
}

A ch csatorna logikai. Két gorutin fut párhuzamosan a fő- funkció. Az 1. Goroutine a befejezését jelzi a igaz értéket a csatornába ch. A Goroutine 2 a befejezési jelre vár azáltal, hogy értéket kap a csatornától. Végül a fő gorutin megvárja a második gorutin befejezési jelét.

A Gin segítségével webalkalmazásokat készíthet

A Go with Ginben nagy teljesítményű webalkalmazásokat készíthet, miközben kihasználja a Go párhuzamossági funkcióit.

A Gin segítségével hatékonyan kezelheti a HTTP-útválasztást és a köztes szoftvert. Használja ki a Go beépített párhuzamossági támogatását azáltal, hogy gorutinokat és csatornákat alkalmaz olyan feladatokhoz, mint az adatbázis-lekérdezések, API-hívások vagy más blokkoló műveletek.