Implémentation des fonctions golang et goroutine dans différentes bibliothèques de concurrence

Dans le langage Go, les fonctions et les Goroutines implémentent la programmation concurrente. Les fonctions Go peuvent être exécutées simultanément via le mot-clé go, et les Goroutines sont des threads légers qui atteignent la concurrence en allouant une nouvelle pile et en exécutant une fonction donnée. Dans des cas pratiques, les verrous mutex (package de synchronisation) sont utilisés pour empêcher la concurrence des données, tandis que le contexte (package de contexte) est utilisé pour contrôler l'annulation et l'expiration des fonctions concurrentes.

Implémentation des fonctions Go et Goroutine dans différentes bibliothèques de concurrence

Go fournit une variété de primitives de concurrence, permettant aux développeurs d'écrire facilement des programmes simultanés. Dans cet article, nous explorerons deux des bibliothèques de concurrence les plus couramment utilisées :

• package de synchronisation  : contient des types de synchronisation de base tels que les mutex (Mutex) et les variables de condition (Cond).
• package contextuel : utilisé pour gérer l'expiration et l'annulation des demandes ou des opérations.

Fonction

Les fonctions Go peuvent être exécutées en parallèle, réalisant ainsi la concurrence. Les fonctions simultanées peuvent être créées en utilisant la syntaxe suivante :

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

Goroutine

Goroutine est un thread Go léger qui peut être exécuté simultanément. Lorsqu'un Goroutine est créé, une nouvelle pile lui sera allouée et commencera à exécuter la fonction donnée. Goroutine peut être créé en utilisant la syntaxe suivante :

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

Cas pratique : Mutex lock

Le verrouillage Mutex est utilisé pour coordonner l'accès aux ressources partagées et empêcher la concurrence des données. Le package de synchronisation fournit le type Mutex, que nous pouvons utiliser pour protéger les variables partagées. Mutex 类型，我们可以使用它来保护共享变量。

import (
    "sync"
    "fmt"
)

var (
    count int
    mu sync.Mutex
)

func increment() {
    mu.Lock()
    count++
    mu.Unlock()
}

func main() {
    for i := 0; i < 1000; i++ {
        go increment()
    }
    fmt.Println(count) // 输出: 1000
}

实战案例：Context

Context 用于传递请求或操作的取消状态。context 包提供了 Context 和 CancelFunc

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

func main() {
    // 创建一个 Context，并在 1 秒后取消
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()

    go func() {
        // 在 Context 被取消之前，不断打印
        for {
            select {
            case <-ctx.Done():
                fmt.Println("Context cancelled")
                break
            default:
                fmt.Println("Still running...")
                time.Sleep(100 * time.Millisecond)
            }
        }
    }()

    // 等待 Goroutine 完成或 Context 被取消
    <-ctx.Done()
}

Cas pratique : Contexte

🎜🎜Le contexte permet de passer le statut d'annulation de la demande ou de l'opération. Le package context fournit les types Context et CancelFunc, que nous pouvons utiliser pour contrôler les fonctions concurrentes. 🎜rrreee🎜Dans différentes bibliothèques de concurrence, les fonctions et les Goroutines peuvent être implémentées légèrement différemment, mais leurs concepts de base restent les mêmes. Les types de synchronisation sont utilisés pour coordonner l'accès aux ressources partagées, tandis que le contexte est utilisé pour gérer l'annulation et l'expiration des fonctions simultané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!