Mécanisme de communication de la coroutine Golang

Les coroutines Go communiquent via des canaux (envoi et réception de données) et des primitives de synchronisation (gestion de l'accès aux ressources partagées). Les canaux sont utilisés pour transférer des données entre les coroutines via des opérations d'envoi et de réception. Les primitives de synchronisation incluent des mutex (pour contrôler l'accès aux ressources partagées), des variables de condition (pour attendre qu'une condition soit remplie avant de poursuivre l'exécution) et des signaux ponctuels (pour garantir qu'une opération n'est effectuée qu'une seule fois).

Mécanisme de communication Go coroutine

Qu'est-ce qu'une coroutine ?

Les coroutines sont des threads légers qui permettent une exécution simultanée sans créer de threads système séparés. Il fournit un moyen de programmation simultanée plus efficace et économe en ressources.

Mécanisme de communication

Les coroutines Go peuvent communiquer via les deux mécanismes suivants :

• Canal : Un canal sans tampon ou avec tampon utilisé pour envoyer et recevoir des données.
• Primitives de synchronisation : telles que les verrous mutex, les variables de condition et les signaux ponctuels, utilisées pour gérer l'accès simultané aux ressources partagées.

Channel

Channel est un mécanisme de communication synchrone qui fournit deux opérations :

• chan : Envoie la valeur <code>v à l'allée. chan：将值 <code>v 发送到通道。
• ：从通道接收值。

以下示例演示如何使用管道在两个协程之间传递消息：

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建一个无缓冲管道
    message := make(chan string)

    // 启动一个发送协程
    go func() {
        // 向通道发送消息
        message <- "Hello from the sending goroutine!"
    }()

    // 启动一个接收协程
    go func() {
        // 从通道接收消息
        msg := <-message
        fmt.Println(msg) // 输出: Hello from the sending goroutine!
    }()

    // 等待协程完成
    var wg sync.WaitGroup
    wg.Add(2)
    wg.Wait()
}

同步原语

同步原语可用于协调对共享资源的访问。以下是一些常用的同步原语：

• 互斥锁（sync.Mutex）：允许一次只有一个协程访问共享资源。
• 条件变量（sync.Cond）：用于等待某个条件满足后再继续执行。
• 一次性信号（sync.Once : recevez la valeur du canal.

L'exemple suivant montre comment utiliser des canaux pour transmettre des messages entre deux coroutines :

package main

import (
    "fmt"
    "sync"
)

var counter int
var mu sync.Mutex

func main() {
    // 启动多个协程同时对共享变量进行加法
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            counter++
            mu.Unlock()
            wg.Done()
        }()
    }

    wg.Wait()
    fmt.Println(counter) // 输出: 100
}

Primitives de synchronisation 🎜🎜🎜Les primitives de synchronisation peuvent être utilisées pour coordonner l'accès aux ressources partagées. Voici quelques primitives de synchronisation couramment utilisées : 🎜🎜🎜🎜Verrouillage Mutex (sync.Mutex) : 🎜Autorise une seule coroutine à accéder aux ressources partagées à la fois. 🎜🎜🎜Variable de condition (sync.Cond) : 🎜Utilisée pour attendre qu'une certaine condition soit remplie avant de poursuivre l'exécution. 🎜🎜🎜Signal unique (sync.Once) : 🎜Garantit qu'une opération n'est exécutée qu'une seule fois. 🎜🎜🎜L'exemple suivant montre comment utiliser un mutex pour protéger l'accès à une ressource partagée : 🎜rrreee🎜Comprendre le mécanisme de communication des coroutines Go est essentiel pour développer des applications simultanées efficaces et évolutives. 🎜

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!