Méthodes d'implémentation synchrones et asynchrones des fonctions Golang

Golang est un langage de programmation de haut niveau qui prend en charge la programmation simultanée. Il fournit de riches mécanismes de programmation simultanée et des fonctionnalités de syntaxe pour faciliter la mise en œuvre de programmes multithreads ou multi-coroutines complexes. Parmi elles, la synchronisation et l'asynchrone sont deux méthodes couramment utilisées en programmation simultanée. Cet article présentera les méthodes d'implémentation synchrone et asynchrone des fonctions Golang et leurs scénarios d'utilisation.

1. Méthode d'implémentation de la fonction synchrone

La fonction synchrone signifie que lors de l'exécution de la fonction, le programme attendra que la fonction renvoie le résultat avant de continuer à exécuter la prochaine opération. Dans Golang, les méthodes d'implémentation de la fonction de synchronisation couramment utilisées sont les suivantes.

1. Appel de blocage

L'appel de blocage est la méthode la plus couramment utilisée pour implémenter des fonctions synchrones, c'est-à-dire que lorsqu'une fonction est appelée, le programme bloquera toujours en attendant le fonction pour terminer l’exécution et renvoyer le résultat. Passez ensuite à l’étape suivante. Par exemple, la fonction f dans le code suivant est un appel bloquant :

func f() int {
    time.Sleep(time.Second * 5)
    return 42
}

func main() {
    x := f()
    fmt.Println(x)
}

La fonction f dans le code ci-dessus simule une opération fastidieuse et prend 5 secondes pour renvoyer le résultat. Lorsque la fonction f est appelée dans la fonction principale, le programme bloquera toujours et attendra que la fonction f termine son exécution et renvoie le résultat avant de passer à l'étape suivante.

2. Synchronisation multi-thread

Golang fournit un mécanisme de programmation multi-thread qui peut utiliser plusieurs threads pour effectuer des tâches en parallèle. Lorsque plusieurs threads accèdent à la même ressource en même temps, des opérations de synchronisation sont nécessaires pour éviter les conditions de concurrence. Les méthodes de synchronisation courantes incluent les verrous mutex, les variables de condition, les opérations atomiques, etc. Voici un exemple de code qui utilise un verrou mutex pour réaliser une synchronisation multithread :

var count int
var mut sync.Mutex

func increment() {
    mut.Lock()
    count++
    mut.Unlock()
}

func main() {
    for i := 0; i < 1000; i++ {
        go increment()
    }
    time.Sleep(time.Second)
    fmt.Println(count)
}

Dans le code ci-dessus, la fonction d'incrémentation est une fonction qui effectue une opération d'incrémentation et plusieurs threads comptent dans le verrouillage mutex. Fonctionnement synchrone des variables pour éviter les conditions de concurrence. Le programme exécute la fonction d'incrémentation 1 000 fois en parallèle via plusieurs threads et génère finalement la valeur de count.

2. Méthode d'implémentation de la fonction asynchrone

La fonction asynchrone signifie que lors de l'exécution de la fonction, le programme n'attend pas que la fonction renvoie le résultat, mais continue directement pour effectuer l'opération suivante. Une fois la fonction exécutée, le résultat sera transmis au programme via une fonction de rappel ou une notification de message. Dans Golang, les méthodes d'implémentation de fonctions asynchrones couramment utilisées sont les suivantes.

1. Coroutine

Coroutine est un thread léger dans Golang qui peut exécuter plusieurs coroutines simultanément dans un seul thread. Les coroutines sont très pratiques à utiliser et peuvent être démarrées via le mot-clé go.

Ce qui suit est un exemple de code pour utiliser des coroutines pour implémenter des fonctions asynchrones :

func f() int {
    time.Sleep(time.Second * 5)
    return 42
}

func main() {
    ch := make(chan int)
    go func() {
        ch <- f()
    }()
    fmt.Println("doing other things")
    x := <-ch
    fmt.Println(x)
}

Dans le code ci-dessus, le canal ch est utilisé pour implémenter des opérations asynchrones. Démarrez une coroutine dans la fonction principale et transmettez le résultat de l'exécution de la fonction f au programme principal via le canal ch. Une fois que d'autres opérations ont été effectuées dans le programme principal, le résultat de l'exécution de la fonction f est reçu via le canal pour terminer l'opération asynchrone.

2. Fonction de rappel

La fonction de rappel fait référence à la transmission du résultat au programme en appelant une fonction de rappel pré-enregistrée après l'exécution de la fonction asynchrone. Voici un exemple de code qui utilise des fonctions de rappel pour implémenter des fonctions asynchrones :

func f(callback func(int)) {
    time.Sleep(time.Second * 5)
    callback(42)
}

func main() {
    f(func(x int) {
        fmt.Println(x)
    })
    fmt.Println("doing other things")
}

Dans le code ci-dessus, la fonction f utilise des fonctions de rappel pour implémenter des opérations asynchrones. En appelant la fonction de rappel pré-enregistrée, le résultat de l'exécution de la fonction f est transmis au programme. Une fois que d'autres opérations ont été effectuées dans le programme principal, le résultat de l'exécution de la fonction f est généré.

3. Scénarios d'utilisation synchrone et asynchrone

Les fonctions synchrones et asynchrones ont chacune leurs propres avantages et inconvénients et doivent être sélectionnées en fonction des besoins spécifiques de l'entreprise.

Lorsque vous avez simplement besoin d'obtenir le résultat de l'exécution d'une certaine fonction, comme les opérations de requête http, etc., les fonctions synchrones sont souvent utilisées. Si vous devez effectuer des opérations fastidieuses ou exécuter plusieurs tâches en même temps, les fonctions asynchrones sont plus adaptées. Par exemple, lors du téléchargement de fichiers volumineux, vous pouvez utiliser des fonctions asynchrones pour mettre en œuvre des téléchargements simultanés et augmenter la vitesse de téléchargement ; lors du traitement des demandes réseau, vous pouvez utiliser des fonctions asynchrones pour traiter les demandes et réduire le temps d'attente.

En bref, les fonctions synchrones et asynchrones ont de meilleurs effets d'utilisation dans différents scénarios, et nous devons choisir en fonction de la situation réelle.

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!