Coopération entre la coroutine Golang et le canal

La coopération des coroutines et des canaux peut réaliser une programmation simultanée et améliorer les performances et le débit du programme. Grâce aux canaux, les coroutines peuvent communiquer et échanger des données en toute sécurité et efficacement. Les principales étapes sont les suivantes : Créer un canal pour recevoir des tâches. Démarrez plusieurs coroutines pour recevoir et traiter les tâches de Channel. Créez une tâche sur le fil de discussion principal et envoyez-la au canal. La fermeture du canal indique à la coroutine qu'il n'y a plus de tâches. Utilisez sync.WaitGroup pour attendre la fin de toutes les coroutines.

Coopération entre la coroutine Golang et Channel

Introduction

Coroutine est un thread léger en mode utilisateur Par rapport aux processus ou aux threads, la création et la destruction de coroutines consomment moins de ressources. Channel est un mécanisme du langage Go pour la communication entre goroutines. La combinaison de coroutines et de canaux permet une programmation simultanée, améliorant ainsi les performances et le débit du programme.

Cas pratique

Utilisons un cas pratique pour démontrer la coopération entre les coroutines et les canaux. Ce cas montrera comment traiter un ensemble de tâches en parallèle.

// 任务定义
type Task struct {
    ID   int
    Data []int
}

// 任务处理函数
func processTask(task *Task) {
    // 耗时处理
    fmt.Printf("Processing task %d\n", task.ID)
    time.Sleep(time.Second * 2)
}

func main() {
    // 创建一个 channel 用于接收任务
    tasks := make(chan *Task, 10)

    // 启动 4 个协程来处理任务
    for i := 0; i < 4; i++ {
        go func() {
            for {
                // 从 channel 中接收任务
                task := <-tasks

                // 处理任务
                processTask(task)
            }
        }()
    }

    // 创建任务并将其发送到 channel
    for i := 0; i < 10; i++ {
        task := &Task{
            ID:   i,
            Data: []int{i, i + 1, i + 2},
        }
        tasks <- task
    }

    // 关闭 channel 告知协程没有更多任务
    close(tasks)

    // 等待所有协程完成
    var wg sync.WaitGroup
    wg.Add(4)
    for i := 0; i < 4; i++ {
        go func() {
            // 协程退出时通知WaitGroup
            wg.Done()
        }()
    }
    wg.Wait()
}

Processus d'exécution du code :

1. Créez un canal tâches pour recevoir des tâches. tasks 用于接收任务。
2. 启动 4 个协程，每个协程都从 channel 中接收任务并进行处理。
3. 在主线程中创建 10 个任务并发送到 channel。
4. 关闭 channel 告知协程没有更多任务。
5. 使用 sync.WaitGroup
Démarrez 4 coroutines, chaque coroutine reçoit les tâches du canal et les traite.

Créez 10 tâches dans le fil de discussion principal et envoyez-les à la chaîne.

Fermez la chaîne pour indiquer à la coroutine qu'il n'y a plus de tâches.

🎜Utilisez sync.WaitGroup pour attendre que toutes les coroutines soient terminées. 🎜🎜🎜Résumé🎜🎜La combinaison de coroutines et de canaux peut réaliser une programmation simultanée, améliorant ainsi les performances et le débit du programme. En utilisant des canaux, les coroutines peuvent communiquer et échanger des données de manière sûre et efficace. Ceci est utile pour gérer un grand nombre de tâches ou de scénarios nécessitant un traitement parallèle. 🎜

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!