Application de la programmation simultanée de la fonction Golang dans les grands projets

La programmation simultanée peut améliorer les performances et l'évolutivité des grands projets Go. 1. Valeur originale de concurrence : goroutine est un thread léger et le canal est un tampon pour transférer des données en toute sécurité. 2. Mode simultanéité : la simultanéité du pipeline est utilisée dans le modèle producteur-consommateur ; le pool de travail maintient un nombre fixe de goroutines, en attente d'exécution du travail. 3. Cas pratique : Le service back-end e-commerce utilise des pipelines pour traiter les commandes simultanément et utilise des pools de travail pour optimiser les connexions aux bases de données.

Application de la programmation simultanée fonctionnelle Go dans les grands projets

Vue d'ensemble

Dans les grands projets Go, tirer pleinement parti de la programmation simultanée peut améliorer considérablement les performances et l'évolutivité. Le mécanisme de concurrence intégré de Go fournit des outils puissants pour écrire du code parallèle efficace. Les

Concurrency primitives

goroutines sont des threads légers dans Go qui peuvent exécuter du code sans verrouiller l'ensemble du processus. Pour créer une goroutine, utilisez le mot-clé go :

go func() {
    // 并发执行的代码
}

channel est un tampon utilisé pour transmettre en toute sécurité des données entre goroutines. Les canaux ont des types pour garantir la sécurité des types de données :

var dataChannel chan int
func main() {
    dataChannel = make(chan int)
    go sendData(dataChannel)
    receivedData := <-dataChannel
    fmt.Println("Received data:", receivedData)
}

func sendData(ch chan int) {
    ch <- 42 // 发送数据
}

Mode simultané

Concurrence de pipeline Utilisez des canaux pour transmettre des données d'une goroutine à une autre, implémentant ainsi des modèles de producteur et de consommateur dans le pipeline :

func pipeExample() {
    numJobs := 1000

    input := make(chan int)
    processed := make(chan int)

    // 启动一个 goroutine 表示消费者
    go func() {
        for {
            select {
            case job := <-input:
                processedData := process(job)
                processed <- processedData
            }
        }
    }()

    // 启动多个 goroutine 表示生产者
    for i := 0; i < numJobs; i++ {
        go func(i int) {
            input <- i
        }(i)
    }

    close(input) // 当所有工作都完成时关闭输入通道

    // 等待所有工作处理完成
    for i := 0; i < numJobs; i++ {
        _ = <-processed
    }
}

Le pool de travail maintient un nombre fixe de goroutines qui attendent que le travail soit exécuté :

func workerPoolExample() {
    jobs := make(chan int)
    results := make(chan int)

    // 启动一个 goroutine 表示工作池中的每一个 worker
    for w := 1; w <= numWorkers; w++ {
        go worker(jobs, results)
    }

    for j := 0; j < numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= numJobs; a++ {
        _ = <-results // 等待接收所有结果
    }
}

func worker(jobs <-chan int, results chan<- int) {
    for j := range jobs {
        result := process(j)
        results <- result
    }
}

Cas pratique

Un grand site de e-commerce a développé un service backend utilisant Go pour traiter les commandes en ligne. Le service doit traiter des centaines de commandes entrantes en parallèle et utilise une base de données MySQL pour stocker les détails des commandes.

Utilisation de la concurrence de pipeline

Le service utilise la concurrence de pipeline pour implémenter le pipeline de traitement des commandes :

• La goroutine du producteur qui obtient la commande de l'API REST.
• Un ensemble de Goroutines consommateurs récupère les commandes du pipeline, valide les commandes et les stocke dans la base de données.

Utilisation des pools de travail

Le service utilise également des pools de travail pour optimiser les connexions à la base de données :

• Les pools de travail maintiennent un groupe de connexions à la base de données inactives.
• Chaque fois qu'une connexion à la base de données est nécessaire, le service obtient une connexion du pool de travailleurs et la renvoie à la goroutine du consommateur.
• Une fois l'utilisation terminée, la goroutine consommateur renvoie la connexion au pool de travailleurs.

En combinant la simultanéité du pipeline et les pools de travailleurs, le service est capable de traiter efficacement plusieurs commandes entrantes simultanément et d'optimiser l'utilisation des ressources de la base de données.

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!