Home-theater-designers
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öä.
Päivän MUO video JATKA SISÄLLÖLLÄ VIERÄTÄ
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.
func main() {
go function1() // Create and execute goroutine for function1
go function2() // Create and execute goroutine for function2
// ...
}
func function1() {
// Code for function1
}
func function2() {
// Code for function2
}
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ä:
package main
import (
"fmt"
"time"
)
func printText() {
for i := 1; i <= 5; i++ {
fmt.Println("Printing text", i)
time.Sleep(1 * time.Second)
}
}
func main() {
go printText() // Start a goroutine to execute the printText function concurrently
// Perform other tasks in the main goroutine
for i := 1; i <= 5; i++ {
fmt.Println("Performing other tasks", i)
time.Sleep(500 * time.Millisecond)
}
// Wait for the goroutine to finish
time.Sleep(6 * time.Second)
}
The printText 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 go printText , joka käynnistää printText toimii erillisenä samanaikaisena gorutiinina, joka mahdollistaa funktion suorittamisen samanaikaisesti muun koodin kanssa pää toiminto.
Lopuksi varmistaaksesi, että ohjelma ei poistu ennen printText Gorutine viimeistely, aika. Nuku 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 viestinnän ja synkronoinnin kanavien kautta, mikä tekee samanaikaisen koodin kirjoittamisesta helpompaa kuin perinteiset säikeet, jotka vaativat usein manuaalisia synkronointimekanismeja, kuten lukkoja ja semaforeja.
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ä:
func main() {
// Create an unbuffered channel of type string
ch := make(chan string)
// Goroutine 1: Sends a message into the channel
go func() {
ch <- "Hello, Channel!"
}()
// Goroutine 2: Receives the message from the channel
msg := <-ch
fmt.Println(msg) // Output: Hello, Channel!
}
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öä:
func main() {
// Unbuffered channel
ch1 := make(chan int)
// Buffered channel with a capacity of 3
ch2 := make(chan string, 3)
// Sending and receiving values from channels
ch1 <- 42 // Send a value into ch1
value1 := <-ch1 // Receive a value from ch1
ch2 <- "Hello" // Send a value into ch2
value2 := <-ch2 // Receive a value from ch2
}
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.
tämä tiedosto on avoinna toisessa ohjelmassa
func main() {
ch := make(chan bool)
go func() {
fmt.Println("Goroutine 1")
ch <- true // Signal completion
}()
go func() {
<-ch // Wait for the completion signal from Goroutine 1
fmt.Println("Goroutine 2")
}()
<-ch // Wait for completion signal from Goroutine 2
fmt.Println("Main goroutine")
}
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.