Quel framework Golang est le plus adapté à la programmation simultanée ?

Golang Concurrent Programming Framework Guide : Goroutines : coroutines légères pour réaliser un fonctionnement parallèle ; Canaux : pipelines pour la communication entre les goroutines ; WaitGroups : permet à la coroutine principale d'attendre la fin de plusieurs goroutines ; Contexte : fournit des informations contextuelles sur les goroutines, telles que l'annulation et les délais. .

Guide du cadre de programmation simultanée Golang

Introduction

La programmation simultanée est cruciale dans la création d'applications hautes performances et évolutives. Golang fournit un riche ensemble de primitives de concurrence, mais choisir le bon framework peut encore simplifier et améliorer l'efficacité de la programmation simultanée. Cet article explorera divers frameworks de programmation simultanée Golang populaires et montrera leurs cas pratiques.

1. Goroutines

goroutines sont des coroutines légères dans Golang qui peuvent s'exécuter en parallèle dans différents threads. Ils sont très efficaces et faciles à utiliser, particulièrement adaptés aux tâches gourmandes en CPU.

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个 goroutine 来打印消息
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("Hello, world!")
            time.Sleep(100 * time.Millisecond)
        }
    }()

    // 主协程等待 goroutine 完成
    time.Sleep(10 * time.Second)
}

2. Canaux

Les canaux sont des canaux utilisés pour la communication entre les goroutines. Ils offrent un moyen sûr et efficace de transmettre des valeurs et de synchroniser les opérations.

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个 channel 来传递值
    ch := make(chan string)

    // 创建一个 goroutine 来发送数据到 channel
    go func() {
        ch <- "Hello, world!"
    }()

    // 接收 goroutine 发送的值
    msg := <-ch
    fmt.Println(msg)

    time.Sleep(10 * time.Second)
}

3. WaitGroups

WaitGroups permet à la coroutine principale d'attendre la fin de plusieurs goroutines. Cela permet de garantir que l'exécution de la logique principale ne continue pas tant que toutes les goroutines n'ont pas fini de s'exécuter.

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建一个 WaitGroup
    wg := &sync.WaitGroup{}

    // 添加需要等待的 goroutine 数量
    wg.Add(2)

    // 创建并运行 goroutines
    go func() {
        fmt.Println("Goroutine 1")
        wg.Done()
    }()

    go func() {
        fmt.Println("Goroutine 2")
        wg.Done()
    }()

    // 主协程等待 goroutines 完成
    wg.Wait()

    fmt.Println("All goroutines completed")
}

4. Context

Context fournit des informations contextuelles dans goroutine telles que l'annulation et la date limite. Cela permet de gérer les demandes et les opérations simultanées.

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 创建一个 context
    ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)

    // 创建一个 goroutine 并传递 context
    go func(ctx context.Context) {
        fmt.Println("Goroutine started")

        // 监听 context 是否已取消
        select {
        case <-ctx.Done():
            fmt.Println("Goroutine canceled")
            return
        }

        // ... 执行其他操作
    }(ctx)

    // 等待 3 秒后取消 context
    time.Sleep(3 * time.Second)
    ctx.Done()
}

Conclusion

Golang fournit de puissantes primitives de programmation simultanée, et ces frameworks simplifient et améliorent encore l'efficacité de la programmation simultanée. Le choix du bon framework dépend des besoins spécifiques de votre application. En comprenant ces frameworks, les développeurs peuvent créer des programmes parallèles hautes performances et évolutifs.

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!