Implémentation de la coordination des tâches multi-thread et multi-coroutine via les canaux dans Golang

Go utilise les canaux pour réaliser une collaboration de tâches entre multi-threads et multi-coroutines

Aperçu :

Dans Golang, la collaboration de tâches entre multi-threads et multi-coroutines peut être facilement réalisée en utilisant des canaux. Les canaux agissent comme un pont pour la communication entre les threads et peuvent être utilisés pour envoyer et recevoir des données. Grâce aux canaux, nous pouvons réaliser le partage de données et la synchronisation entre multi-threads et multi-coroutines, réalisant ainsi un traitement collaboratif des tâches.

Exemple de code :

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "started job", j)
        time.Sleep(time.Second) // 模拟进行任务处理
        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    numJobs := 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

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

    for a := 1; a <= numJobs; a++ {
        <-results
    }
}

Analyse :

Dans le code ci-dessus, nous avons créé la fonction Worker pour simuler une coroutine qui gère les tâches. Cette fonction reçoit les tâches du canal des travaux et envoie les résultats du traitement au canal des résultats.

Dans la fonction principale, nous créons un canal d'emplois et un canal de résultats et les transmettons respectivement à chaque coroutine de travailleur. Nous utilisons ensuite une boucle pour envoyer des tâches au canal jobs et fermons le canal avec close pour indiquer que toutes les tâches ont été envoyées.

Enfin, nous utilisons une boucle pour recevoir les résultats du traitement depuis le canal des résultats. Étant donné que la taille du tampon du canal de résultats est égale au nombre de tâches, il est garanti que tous les résultats du traitement des tâches seront reçus.

Exécutez le code et le résultat est le suivant :

worker 1 started job 1
worker 2 started job 2
worker 3 started job 3
worker 1 finished job 1
worker 1 started job 4
worker 2 finished job 2
worker 2 started job 5
worker 3 finished job 3
worker 1 finished job 4
worker 2 finished job 5

Comme vous pouvez le voir sur le résultat, les trois coroutines de travail commencent à exécuter des tâches en même temps et envoient les résultats au canal des résultats après avoir terminé les tâches. Étant donné que la taille du tampon du canal de résultats correspond au nombre de tâches, il est garanti que les résultats de toutes les tâches pourront être reçus.

Résumé :

Grâce aux canaux dans Golang, nous pouvons facilement réaliser une collaboration entre les tâches entre multi-threads et multi-coroutines. En utilisant les canaux, nous pouvons facilement communiquer et partager des données entre les threads, améliorant ainsi la simultanéité et l'efficacité des programmes.

Grâce aux exemples de code de cet article, j'espère que les lecteurs pourront mieux comprendre les principes et les méthodes permettant de réaliser une collaboration de tâches multi-thread et multi-coroutine via les canaux dans Golang. Dans le même temps, nous espérons également que les lecteurs pourront utiliser pleinement les fonctionnalités de Channels dans le développement réel et profiter de la programmation simultanée de Golang.

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!