Home-theater-designers
La concurrència és un aspecte crucial del desenvolupament de programari modern, ja que permet als programes gestionar de manera eficient múltiples tasques simultàniament. Podeu escriure programes que executin diverses operacions que permetin millorar el rendiment, la capacitat de resposta i la utilització dels recursos.
Vídeo MUO del dia DESPLACEU PER CONTINUAR AMB EL CONTINGUT
La concurrència és una de les característiques responsables de la ràpida adopció de Go. El suport integrat de Go per a la programació simultània es considera senzill alhora que ajuda a evitar inconvenients habituals com les condicions de carrera i els bloquejos.
Concurrència a Go
Go ofereix un suport robust per a la concurrència mitjançant diversos mecanismes, tots disponibles a la seva biblioteca estàndard i cadena d'eines. Anar programes aconseguir concurrència mitjançant goroutines i canals.
Les goroutines són funcions lleugeres i que executen de manera independent que s'executen simultàniament amb altres goroutines dins del mateix espai d'adreces. Goroutines permet que diverses tasques progressin simultàniament sense una gestió explícita de fils. Les goroutines són més lleugeres que els fils del sistema operatiu i Go pot executar de manera eficient milers o fins i tot milions de goroutines simultàniament.
Els canals són el mecanisme de comunicació per a la coordinació i l'intercanvi de dades entre goroutines. Un canal és un conducte escrit que permet a les goroutines enviar i rebre valors. Els canals proporcionen sincronització per garantir l'intercanvi segur de dades entre goroutines alhora que eviten les condicions de carrera i altres problemes de concurrència habituals.
En combinar goroutines i canals, Go ofereix un model de concurrència potent i senzill que simplifica el desenvolupament de programes concurrents alhora que manté la seguretat i l'eficiència. Aquests mecanismes us permeten utilitzar fàcilment processadors multinucli i crear aplicacions altament escalables i sensibles.
Com utilitzar Goroutines per a l'execució de codi simultània
El temps d'execució Go gestiona les goroutines. Les goroutines tenen la seva pila, cosa que els permet tenir una petjada lleugera amb una mida de pila inicial d'uns quants kilobytes.
Les goroutines es multiplexen a diversos fils del sistema operatiu pel temps d'execució de Go. El programador de temps d'execució de Go els programa als fils disponibles distribuint de manera eficient la càrrega de treball, permetent l'execució simultània de múltiples goroutines en menys fils del sistema operatiu.
notepad ++ compara 2 fitxers
Crear goroutines és senzill. Fareu servir el anar paraula clau seguida d'una trucada de funció per declarar goroutines.
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
}
Quan el programa invoca funció 1() i funció 2() amb el anar paraula clau, el temps d'execució Go executa les funcions simultàniament com a goroutines.
Aquí teniu un exemple d'ús d'una goroutine que imprimeix text a la consola:
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)
}
El imprimir el text La funció imprimeix repetidament text a la consola amb a per bucle que s'executa cinc vegades després d'un retard d'un segon entre cada instrucció amb el paquet de temps .
El principal La funció inicia una goroutine cridant anar a imprimirText , que llança el imprimir el text funcionar com una goroutine concurrent separada que permet que la funció s'executi simultàniament amb la resta del codi del fitxer principal funció.
Finalment, per assegurar-vos que el programa no surti abans de imprimir el text acabats de goroutine, el temps.Dormir La funció atura la goroutine principal durant sis segons. En escenaris del món real, utilitzaríeu mecanismes de sincronització com ara canals o grups d'espera per coordinar l'execució de goroutines.
Ús de canals per a la comunicació i la sincronització
Goroutines tenen suport integrat per a la comunicació i la sincronització a través de canals, cosa que fa que l'escriptura de codi concurrent sigui més fàcil que els fils tradicionals, que sovint requereixen mecanismes de sincronització manuals com ara bloquejos i semàfors.
Podeu pensar en els canals com a canalitzacions per al flux de dades entre goroutines. Una goroutine pot enviar un valor al canal, i una altra goroutine pot rebre aquest valor del canal. Aquest mecanisme garanteix que l'intercanvi de dades sigui segur i sincronitzat.
Fareu servir el <- operador per enviar i rebre dades per canals.
Aquí teniu un exemple que demostra l'ús bàsic dels canals per a la comunicació entre dues goroutines:
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!
}
El canal al principal La funció és un canal sense búfer anomenat cap creat amb el fer () funció. La primera goroutine envia el missatge 'Hola, canal!' al canal utilitzant el <- operador, i la segona goroutine rep el missatge del canal utilitzant el mateix operador. Finalment, el principal La funció imprimeix el missatge rebut a la consola.
Podeu definir canals escrits. Especificareu el tipus de canal en crear-lo. Aquí teniu un exemple que demostra l'ús de diferents tipus de canals:
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
}
El principal La funció crea dos canals: cap 1 és un canal enter sense memòria intermèdia, mentre que ch2 és un canal de cadena de memòria intermèdia amb una capacitat de 3. Podeu enviar i rebre valors cap i des d'aquests canals mitjançant el <- operador (els valors han de ser del tipus especificat).
Podeu utilitzar canals com a mecanismes de sincronització per coordinar l'execució de goroutine aprofitant la naturalesa de bloqueig de les operacions del canal.
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")
}
El cap el canal és booleà. Dues goroutines funcionen simultàniament al principal funció. Goroutine 1 indica la seva finalització enviant a veritat valor al canal cap . Goroutine 2 espera el senyal de finalització rebent un valor del canal. Finalment, la goroutine principal espera el senyal de finalització de la goroutine dos.
Podeu crear aplicacions web a Go With Gin
Podeu crear aplicacions web d'alt rendiment a Go with Gin mentre aprofiteu les funcions de concurrència de Go.
Podeu utilitzar Gin per gestionar l'encaminament HTTP i el middleware de manera eficient. Aprofiteu el suport de concurrència integrat de Go utilitzant goroutines i canals per a tasques com consultes de bases de dades, trucades a l'API o altres operacions de bloqueig.