Johdatus samanaikaisuuteen Gossa

Samanaikaisuus on tärkeä osa nykyaikaista ohjelmistokehitystä, koska sen avulla ohjelmat voivat käsitellä tehokkaasti useita tehtäviä samanaikaisesti. Voit kirjoittaa ohjelmia, jotka suorittavat erilaisia ​​toimintoja, mikä parantaa suorituskykyä, reagointikykyä ja resurssien käyttöä.

Samanaikaisuus on yksi ominaisuuksista, jotka ovat vastuussa Go: n nopeasta käyttöönotosta. Go: n sisäänrakennettua samanaikaisen ohjelmoinnin tukea pidetään yksinkertaisena, mutta se auttaa välttämään yleisiä sudenkuoppia, kuten kilpailuolosuhteita ja umpikujaa.

Samanaikaisuus Gossa

Go tarjoaa vahvan tuen samanaikaisuudelle useiden mekanismien kautta, jotka kaikki ovat saatavilla sen vakiokirjastossa ja työkaluketjussa. Mene ohjelmiin saavuttaa samanaikaisuus gorutiinien ja kanavien kautta.

Gorutiinit ovat kevyitä, itsenäisesti suorittavia toimintoja, jotka toimivat samanaikaisesti muiden samassa osoiteavaruudessa olevien gorutiinien kanssa. Goroutines mahdollistaa useiden tehtävien edetmisen samanaikaisesti ilman nimenomaista säikeenhallintaa. Gorutiinit ovat kevyempiä kuin käyttöjärjestelmäsäikeet, ja Go voi suorittaa tehokkaasti tuhansia tai jopa miljoonia gorutiineja samanaikaisesti.

Kanavat ovat viestintämekanismi koordinointiin ja tiedon jakamiseen gorutiinien välillä. Kanava on kirjoitettu kanava, jonka avulla gorutiinit voivat lähettää ja vastaanottaa arvoja. Kanavat tarjoavat synkronoinnin varmistaakseen turvallisen tietojen jakamisen gorutiinien välillä samalla kun estetään kilpailuolosuhteet ja muut yleiset samanaikaisuusongelmat.

Yhdistämällä gorutiineja ja kanavia, Go tarjoaa tehokkaan ja suoraviivaisen samanaikaisuusmallin, joka yksinkertaistaa samanaikaisten ohjelmien kehittämistä säilyttäen samalla turvallisuuden ja tehokkuuden. Näiden mekanismien avulla voit helposti käyttää moniytimiset prosessorit ja rakentaa erittäin skaalautuvia ja reagoivia sovelluksia.

Gorutiinien käyttäminen samanaikaiseen koodin suorittamiseen

Go-ajoaika hallitsee gorutiineja. Goroutineilla on pinonsa, mikä mahdollistaa niiden kevyen jalanjäljen, joiden alkupinon koko on muutaman kilotavu.

Go-ajoaika multipleksoi Gorutiinit useisiin käyttöjärjestelmäsäikeisiin. Go-ajonaikainen ajoitusohjelma ajoittaa ne käytettävissä oleviin säikeisiin jakamalla työkuorman tehokkaasti, mikä mahdollistaa useiden gorutiinien samanaikaisen suorittamisen harvemmilla käyttöjärjestelmäsäikeillä.

Gorutiinien luominen on yksinkertaista. Tulet käyttämään mennä avainsana, jota seuraa funktiokutsu gorutiinien ilmoittamiseksi.

funcpää() {
mennä funktio1() // Luo ja suorita goutiini funktiolle 1
mennä funktio2() // Luo ja suorita goutiini funktiolle 2
// ...
}
functoiminto1() {
// Koodi funktiolle1
}
functoiminto 2() {
// Koodi funktiolle2
}

Kun ohjelma kutsuu funktio1() ja funktio2() kanssa mennä avainsana, Go-ajoaika suorittaa toiminnot samanaikaisesti gorutiineina.

Tässä on esimerkki konsoliin tekstiä tulostavan gorutiinin käytöstä:

paketti pää
tuonti (
"fmt"
"aika"
)
functulostaTeksti() {
varten minä := 1; minä <= 5; i++ {
 fmt. Println("Tekstitulostus", i)
 aika. Nukkua(1 * aika. Toinen)
 }
}
funcpää() {
mennä printText() // Aloita gorutiini suorittaaksesi printText-funktion samanaikaisesti
// Suorita muita tehtäviä päägorutiinissa
varten minä := 1; minä <= 5; i++ {
 fmt. Println("Muiden tehtävien suorittaminen", i)
 aika. Nukkua(500 * aika. millisekunti)
 }
// Odota, että goritiini päättyy
 aika. Nukkua(6 * aika. Toinen)
}

The tulostaTeksti toiminto tulostaa toistuvasti tekstiä konsoliin a.:lla varten silmukka, joka suoritetaan viisi kertaa yhden sekunnin viiveen jälkeen jokaisen käskyn välillä aikapaketti.

The pää toiminto aloittaa gorutiinin kutsumalla mene printText, joka käynnistää tulostaTeksti toimii erillisenä samanaikaisena gorutiinina, joka mahdollistaa funktion suorittamisen samanaikaisesti muun koodin kanssa pää toiminto.

Lopuksi varmistaaksesi, että ohjelma ei poistu ennen tulostaTeksti Gorutine viimeistely, aika. Nukkua toiminto keskeyttää päägorutiinin kuudeksi sekunniksi. Reaalimaailman skenaarioissa käytät synkronointimekanismeja, kuten kanavia tai odotusryhmiä, koordinoidaksesi gorutiinien suorittamista.

Kanavien käyttäminen viestintään ja synkronointiin

Goroutinesissa on sisäänrakennettu tuki viestintään ja synkronointiin kanavien kautta, mikä tekee kirjoittamisesta samanaikaista koodi helpompaa kuin perinteiset säikeet, jotka vaativat usein manuaalisia synkronointimekanismeja, kuten lukot ja semaforit.

Voit ajatella kanavia putkina tiedonkulkua varten gorutiinien välillä. Yksi gorutiini voi lähettää arvon kanavaan, ja toinen goritiini voi vastaanottaa sen arvon kanavalta. Tämä mekanismi varmistaa, että tiedonvaihto on turvallista ja synkronoitua.

Tulet käyttämään operaattori lähettää ja vastaanottaa tietoja kanavien kautta.

Tässä on esimerkki kanavien peruskäytöstä kahden gorutiinin välisessä viestinnässä:

funcpää() {
// Luo puskuroimaton kanava, jonka tyyppi on merkkijono
 ch := tehdä(chanmerkkijono)
// Gorutiini 1: Lähettää viestin kanavaan
mennäfunc() {
 ch "Hei, kanava!"
 }()
// Goroutine 2: Vastaanottaa viestin kanavalta
 viesti :=  fmt. Tulostus (viesti) // Tulos: Hei, kanava!
}

Kanavassa pää toiminto on puskuroimaton kanava nimeltä ch luotu kanssa tehdä() toiminto. Ensimmäinen gorutiini lähettää viestin "Hei, kanava!" kanavaan käyttämällä operaattori, ja toinen gorutiini vastaanottaa viestin kanavalta käyttäen samaa operaattoria. Lopuksi, pää toiminto tulostaa vastaanotetun viestin konsoliin.

Voit määrittää kirjoitetut kanavat. Määrität kanavan tyypin luomisen yhteydessä. Tässä on esimerkki, joka havainnollistaa eri kanavatyyppien käyttöä:

funcpää() {
// Puskuroimaton kanava
 ch1 := tehdä(chanint)
// Puskuroitu kanava, jonka kapasiteetti on 3
 ch2 := tehdä(chanmerkkijono, 3)
// Arvojen lähettäminen ja vastaanottaminen kanavilta
 ch1 42// Lähetä arvo ch1:een
 arvo1 := // Vastaanota arvo ch1:stä
 ch2 "Hei"// Lähetä arvo ch2:een
 arvo2 := // Vastaanota arvo ch2:sta
}

The pää toiminto luo kaksi kanavaa: ch1 on puskuroimaton kokonaislukukanava, while ch2 on puskuroitu merkkijonokanava, jonka kapasiteetti on 3. Voit lähettää ja vastaanottaa arvoja näille kanaville ja niiltä käyttämällä operaattori (arvojen on oltava määritettyä tyyppiä).

Voit käyttää kanavia synkronointimekanismeina gorutiinin suorittamisen koordinoimiseksi hyödyntämällä kanavatoimintojen estävää luonnetta.

funcpää() {
 ch := tehdä(chanbool)
mennäfunc() {
 fmt. Println("Gorutine 1")
 ch totta// Signaalin valmistuminen
 }()
mennäfunc() {
 // Odota Goroutine 1:n valmistumissignaalia
 fmt. Println("Gorutiini 2")
 }()
 // Odota valmistumissignaalia Goroutine 2:lta
 fmt. Println("Päägorutiini")
}

The ch kanava on looginen. Kaksi gorotiinia suoritetaan samanaikaisesti pää toiminto. Goroutine 1 ilmoittaa valmistumisestaan ​​lähettämällä a totta arvo kanavaan ch. Goroutine 2 odottaa valmistumissignaalia vastaanottamalla arvon kanavalta. Lopuksi päägorutiini odottaa valmistumissignaalia goritiinista kaksi.

Voit rakentaa verkkosovelluksia in Go With Ginillä

Voit rakentaa tehokkaita verkkosovelluksia Go with Ginissä hyödyntäen samalla Gon samanaikaisuusominaisuuksia.

Ginin avulla voit käsitellä HTTP-reititystä ja väliohjelmistoa tehokkaasti. Hyödynnä Go: n sisäänrakennettua samanaikaisuustukea käyttämällä gorutiineja ja kanavia tehtäviin, kuten tietokantakyselyihin, API-kutsuihin tai muihin estotoimintoihin.