Home-theater-designers
La simultanéité est un aspect crucial du développement de logiciels modernes car elle permet aux programmes de gérer efficacement plusieurs tâches simultanément. Vous pouvez écrire des programmes qui exécutent diverses opérations conduisant à une amélioration des performances, de la réactivité et de l'utilisation des ressources.
Vidéo MUO du jour FAITES DÉFILER POUR CONTINUER AVEC LE CONTENU
La simultanéité est l'une des caractéristiques responsables de l'adoption rapide de Go. La prise en charge intégrée de Go pour la programmation simultanée est considérée comme simple tout en aidant à éviter les pièges courants tels que les conditions de concurrence et les blocages.
comment gagner de l'argent avec le codage
Concurrence en Go
Go fournit une prise en charge robuste de la concurrence via divers mécanismes, tous disponibles dans sa bibliothèque et sa chaîne d'outils standard. Allez programmes atteindre la concurrence par le biais de goroutines et de canaux.
Les goroutines sont légères, exécutant indépendamment des fonctions qui s'exécutent simultanément avec d'autres goroutines dans le même espace d'adressage. Les goroutines permettent à plusieurs tâches de progresser simultanément sans gestion explicite des threads. Les goroutines sont plus légères que les threads du système d'exploitation et Go peut exécuter efficacement des milliers, voire des millions de goroutines simultanément.
Les canaux sont le mécanisme de communication pour la coordination et le partage de données entre les goroutines. Un canal est un conduit typé qui permet aux goroutines d'envoyer et de recevoir des valeurs. Les canaux fournissent une synchronisation pour assurer un partage de données sécurisé entre les goroutines tout en évitant les conditions de concurrence et d'autres problèmes de simultanéité courants.
En combinant les goroutines et les canaux, Go fournit un modèle de concurrence puissant et simple qui simplifie le développement de programmes simultanés tout en maintenant la sécurité et l'efficacité. Ces mécanismes vous permettent d'utiliser facilement processeurs multicœurs et créez des applications hautement évolutives et réactives.
Comment utiliser Goroutines pour l'exécution simultanée de code
Le runtime Go gère les goroutines. Les goroutines ont leur pile, ce qui leur permet d'avoir une empreinte légère avec une taille de pile initiale de quelques kilo-octets.
Les goroutines sont multiplexées sur plusieurs threads du système d'exploitation par le runtime Go. Le planificateur d'exécution Go les planifie sur les threads disponibles en distribuant efficacement la charge de travail, permettant l'exécution simultanée de plusieurs goroutines sur moins de threads du système d'exploitation.
La création de goroutines est simple. Vous utiliserez le aller mot-clé suivi d'un appel de fonction pour déclarer des 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
}
Lorsque le programme invoque fonction1() et fonction2() avec le aller , le runtime Go exécute les fonctions simultanément en tant que goroutines.
Voici un exemple d'utilisation d'une goroutine qui imprime du texte sur la console :
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)
}
Le printText fonction imprime à plusieurs reprises du texte sur la console avec un pour boucle qui s'exécute cinq fois après un délai d'une seconde entre chaque instruction avec le forfait horaire .
envoyer des sms gratuits en ligne sur mobile
Le principal la fonction démarre une goroutine en appelant aller imprimerTexte , qui lance le printText fonctionner comme une goroutine concurrente distincte qui permet à la fonction de s'exécuter simultanément avec le reste du code dans le principal fonction.
Enfin, pour s'assurer que le programme ne se termine pas avant le printText goroutine se termine, le le sommeil de temps La fonction met en pause la goroutine principale pendant six secondes. Dans des scénarios réels, vous utiliseriez des mécanismes de synchronisation tels que des canaux ou des groupes d'attente pour coordonner l'exécution des goroutines.
Utilisation de canaux pour la communication et la synchronisation
Les goroutines ont une prise en charge intégrée de la communication et de la synchronisation via les canaux, ce qui facilite l'écriture de code simultané par rapport aux threads traditionnels, qui nécessitent souvent des mécanismes de synchronisation manuelle comme les verrous et les sémaphores.
Vous pouvez considérer les canaux comme des pipelines pour le flux de données entre les goroutines. Une goroutine peut envoyer une valeur dans le canal, et une autre goroutine peut recevoir cette valeur du canal. Ce mécanisme garantit que l'échange de données est sûr et synchronisé.
Vous utiliserez le <- opérateur d'envoyer et de recevoir des données via des canaux.
Voici un exemple démontrant l'utilisation de base des canaux de communication entre deux 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!
}
Le canal dans le principal la fonction est un canal non tamponné nommé ch créé avec le faire() fonction. La première goroutine envoie le message 'Hello, Channel!' dans le canal à l'aide du <- opérateur, et la deuxième goroutine reçoit le message du canal en utilisant le même opérateur. Finalement, le principal La fonction imprime le message reçu sur la console.
Vous pouvez définir des canaux typés. Vous spécifierez le type de chaîne lors de la création. Voici un exemple illustrant l'utilisation de différents types de canaux :
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
}
Le principal La fonction crée deux canaux : ch1 est un canal entier sans tampon, tandis que ch2 est un canal de chaîne tamponné d'une capacité de 3. Vous pouvez envoyer et recevoir des valeurs vers et depuis ces canaux à l'aide de la <- opérateur (les valeurs doivent être du type spécifié).
Vous pouvez utiliser des canaux comme mécanismes de synchronisation pour coordonner l'exécution d'une goroutine en tirant parti de la nature bloquante des opérations de 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")
}
Le ch canal est booléen. Deux goroutines s'exécutent simultanément dans le principal fonction. Goroutine 1 signale son achèvement en envoyant un vrai valeur dans le canal ch . Goroutine 2 attend le signal d'achèvement en recevant une valeur du canal. Enfin, la goroutine principale attend le signal d'achèvement de la goroutine deux.
Vous pouvez créer des applications Web dans Go With Gin
Vous pouvez créer des applications Web hautes performances dans Go avec Gin tout en tirant parti des fonctionnalités de simultanéité de Go.
comment nettoyer un ventilateur ps4 sans le démonter
Vous pouvez utiliser Gin pour gérer efficacement le routage HTTP et le middleware. Tirez parti de la prise en charge intégrée de la simultanéité de Go en utilisant des goroutines et des canaux pour des tâches telles que les requêtes de base de données, les appels d'API ou d'autres opérations de blocage.