Cas pratiques de contrôle de concurrence des fonctions Golang dans les projets d'ingénierie

Implémentation de la concurrence de contrôle de la concurrence du langage Go : utilisez le thread léger "goroutine" pour implémenter des tâches d'exécution parallèles. Implémentation synchrone : utilisez « canal » pour transférer des données entre les goroutines afin d'obtenir une communication synchrone. Cas pratique : Traitez les requêtes HTTP en parallèle et créez une goroutine pour traiter les tâches chronophages de manière asynchrone afin d'améliorer les performances et la réactivité du serveur.

Un cas pratique de contrôle de concurrence des fonctions Golang dans des projets d'ingénierie

Lorsque vous utilisez Go pour construire un système distribué, le contrôle de concurrence est crucial. Go fournit de puissants mécanismes de concurrence, notamment des goroutines et des canaux, vous permettant de créer des applications hautes performances et évolutives.

Utilisez Goroutine pour obtenir la concurrence

Goroutine est un thread léger dans Go. Vous pouvez exécuter des fonctions en parallèle en utilisant le mot-clé go :

func main() {
    go func() {
        fmt.Println("Hello from goroutine")
    }()
}

Le code ci-dessus créera une nouvelle goroutine qui s'exécutera en parallèle du programme principal.

Utilisez Channel pour réaliser la synchronisation

Channel est utilisé pour transmettre des données entre les goroutines. Ils se comportent comme des files d'attente, une goroutine (expéditeur) peut écrire des données sur le canal et une autre goroutine (récepteur) peut en lire des données.

func main() {
    ch := make(chan int)
    go func() {
        ch <- 42
    }()
    fmt.Println(<-ch) // 读取 channel 中的数据
}

Dans l'exemple ci-dessus, une goroutine écrit la valeur 42 sur le canal, et le programme principal lit la valeur du canal et l'imprime.

Cas pratique : Traitement parallèle des requêtes HTTP

Le code suivant montre un exemple d'utilisation du langage Go pour traiter les requêtes HTTP en parallèle :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        go func() {
            //并行执行一个耗时的任务
            processRequest(r)
        }()

        //立即向客户端响应
        fmt.Fprintf(w, "HTTP 200 OK\n")
    })

    http.ListenAndServe(":8080", nil)
}

func processRequest(r *http.Request) {
    fmt.Println("耗时的任务正在处理")
}

Dans ce cas, nous créons une nouvelle goroutine pour traiter le temps- consommant des tâches de manière asynchrone, en même temps, la requête HTTP reçoit immédiatement une réponse au client. Cela peut améliorer considérablement les performances et la réactivité du serveur.

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!