Comment rendre Golang asynchrone

Méthode asynchrone Golang : 1. Mode requête/réponse simultanée, dans lequel une goroutine envoie une requête à une autre goroutine, puis attend la réponse ; 2. Dans lequel plusieurs goroutines reçoivent des données d'un canal et envoient le résultat à un autre. après traitement du canal.

L'environnement d'exploitation de ce tutoriel : système windows10, version golang1.20.1, ordinateur DELL G3.

Golang est un langage de programmation puissant et efficace. Il fournit un riche mécanisme de programmation simultanée, l'une de ses fonctionnalités importantes est la programmation asynchrone. La programmation asynchrone peut aider les développeurs à améliorer les performances et l'évolutivité des programmes tout en offrant une meilleure expérience utilisateur. Dans cet article, nous verrons comment implémenter la programmation asynchrone dans Golang.

Dans Golang, la programmation asynchrone peut être implémentée via goroutine et canal. Goroutine est un thread léger qui peut s'exécuter dans un environnement d'exécution simultanée, et le canal est un pipeline utilisé pour la communication entre les goroutines.

1. Présentons la goroutine. Goroutine est un thread léger géré par l'environnement d'exécution du langage Go. À l'aide de goroutines, vous pouvez exécuter plusieurs fonctions simultanément dans un programme sans créer de threads supplémentaires. Démarrez une goroutine en utilisant le mot-clé go, par exemple :

gofuncName()

Dans l'exemple ci-dessus, funcName est un nom de fonction, et en appelant le mot-clé go, la fonction sera exécutée de manière asynchrone dans une nouvelle goroutine. L'utilisation de goroutine permet au programme d'exécuter plusieurs fonctions en même temps, améliorant ainsi les performances de concurrence du programme.

2. Jetons un coup d'œil à la chaîne. Channel est le pont de communication entre les goroutines. Il peut être utilisé pour envoyer et recevoir des valeurs, permettant ainsi la synchronisation entre différentes goroutines. Dans Golang, vous pouvez utiliser la fonction make pour créer un canal, par exemple :

ch:=make(chandataType)

Dans l'exemple ci-dessus, dataType est le type de données que le canal peut recevoir. La synchronisation entre les goroutines peut être réalisée à l'aide de canaux, par exemple :

ch<-value//发送数据到channel
result:=<-ch//从channel接收数据

Dans l'exemple ci-dessus, ch <- value signifie envoyer une valeur au canal et <-ch signifie recevoir des données du canal. Les canaux peuvent être utilisés pour réaliser la synchronisation et le transfert de données entre deux ou plusieurs goroutines.

3. Nous présenterons quelques modèles de programmation asynchrone courants. Le premier est le modèle demande/réponse simultanée, dans lequel une goroutine envoie une requête à une autre goroutine puis attend une réponse. Ceci peut être réalisé en utilisant des goroutines et des canaux, par exemple :

funcworker(requestchanint,responsechanint){
for{
req:=<-request//从channel接收请求
//处理请求
result:=req*2//假设这是一个耗时的操作
response<-result//发送响应到channel
}
}
funcmain(){
request:=make(chanint)
response:=make(chanint)
goworker(request,response)
//发送请求
request<-10
//等待响应
result:=<-response
fmt.Println(result)//输出20
}

Dans l'exemple ci-dessus, la fonction de travail reçoit deux canaux, requête et réponse, en tant que paramètres. Il utilise une boucle infinie pour écouter les demandes canal et traiter la demande. Le résultat est ensuite envoyé au canal de réponse. La fonction principale crée une demande et une réponse canal et a démarré la goroutine de la fonction de travail. La fonction principale envoie 10 à la demande canal, puis attendez la réponse du travailleur et imprimez le résultat.

Un autre modèle courant est le modèle fan-out/fan-in, dans lequel plusieurs goroutines reçoivent des données d'un canal et envoient le résultat à un autre canal après le traitement. Cela peut aider à améliorer la vitesse de traitement et le débit du programme, par exemple :

funcworker(inputchanint,outputchanint){
for{
data:=<-input//从channel接收数据
//处理数据
result:=data*2//假设这是一个耗时的操作
output<-result//发送结果到channel
}
}
funcmain(){
input:=make(chanint)
output:=make(chanint)
fori:=0;i<10;i++{
goworker(input,output)
}
//发送数据
fori:=0;i<10;i++{
input<-i
}
//等待处理结果
fori:=0;i<10;i++{
result:=<-output
fmt.Println(result)
}
}

Dans l'exemple ci-dessus, la fonction de travail reçoit les données du canal d'entrée et envoie le résultat à la sortie après le traitement. canal. La fonction Main crée une entrée et une sortie chaîne et a démarré 10 goroutines de travail. La fonction principale envoie les données de 0 à 9 à l'entrée canal et attendez le résultat du traitement. Les résultats du traitement seront reçus du canal de sortie et imprimés.

En plus d'utiliser des goroutines et des canaux, Golang fournit également d'autres mécanismes de contrôle de concurrence et de synchronisation, tels que les verrous mutex (sync.Mutex), les variables de condition (sync.Cond), les opérations atomiques (atomic), etc. Ces mécanismes peuvent aider les développeurs à gérer efficacement les accès simultanés et à exploiter les ressources partagées.

Dans les applications réelles, l'utilisation correcte de la programmation asynchrone peut améliorer considérablement les performances et l'évolutivité du programme. Les développeurs doivent choisir le mode de concurrence approprié en fonction de la situation réelle et gérer soigneusement les problèmes d'accès simultané et de ressources partagées.

Pour résumer, Golang fournit un puissant mécanisme de programmation concurrente, dont la programmation asynchrone est l'une des fonctionnalités clés. En utilisant des goroutines et des canaux, la programmation asynchrone et le contrôle de concurrence peuvent être facilement mis en œuvre. Dans les applications réelles, les développeurs doivent choisir le mode de concurrence approprié en fonction de la situation réelle pour améliorer les performances et l'évolutivité du programme. .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!