Comment les pipelines Golang sont utilisés pour la communication interfonctionnelle

Pipeline en langage Go est un canal sans tampon utilisé pour transférer des données entre Goroutines. Il permet à Goroutine de communiquer de manière asynchrone, améliorant ainsi l'efficacité et l'évolutivité du programme. Les tuyaux peuvent être utilisés pour écrire et lire des données, à l'aide de l'opérateur

Pipeline en langage Go : mécanisme de communication inter-fonctions

Pipeline est un canal non tamponné utilisé pour transférer des données entre Goroutines (fonctions simultanées). Il permet aux Goroutines de communiquer de manière asynchrone, améliorant ainsi l'efficacité et l'évolutivité du programme.

Création de pipeline

Les pipelines peuvent être créés par make(chan type), où type est le type de données transmis dans le pipeline. Par exemple, créez un canal pour transférer des entiers : make(chan type) 创建，其中 type 是管道中传递数据的类型。例如，创建一个用于传输整型的管道：

ch := make(chan int)

管道写入

要将数据写入管道，请使用 操作符，它将值发送到管道。例如，将数字 10 发送到管道 <code>ch：

ch <- 10

管道读取

要从管道读取数据，请使用 操作符，它将从管道中接收值。例如，从管道 <code>ch 接收一个整数并存储在变量 i

i := <-ch

Écriture de canal

Pour écrire des données dans un canal, utilisez l'opérateur , qui envoie la valeur au canal. Par exemple, envoyer le nombre 10 au tuyau <code>ch :

package main

import (
    "fmt"
    "math"
)

func main() {
    // 创建一个管道来传输数字
    ch := make(chan int)

    // 定义一个 goroutine 来计算平方数
    go func() {
        for i := 1; ; i++ {
            // 将数字发送到管道
            ch <- i * i
        }
    }()

    // 从管道中获取平方数并打印
    for {
        // 从管道接收平方数
        num := <-ch

        // 打印平方数
        fmt.Println(num)

        // 检查是否为 100，如果是则退出
        if num >= 100*100 {
            break
        }
    }
}

Lecture du tuyau

Pour lire les données du tuyau, utilisez l'opérateur , qui lira de Recevoir les valeurs dans le tube. Par exemple, recevoir un entier du tube <code>ch et le stocker dans la variable i : 🎜rrreee🎜Cas pratique : calcul de nombres carrés🎜🎜Ce qui suit est un cas pratique montrant comment utiliser les pipelines pour calculer les nombres carrés entre les Goroutines : 🎜rrreee🎜 Dans cet exemple, une Goroutine continue de générer des nombres carrés et de les envoyer au tuyau, et l'autre Goroutine continue de recevoir des nombres carrés du tuyau et de les imprimer. Il démontre la puissance des tuyaux dans le calcul asynchrone et la communication interfonctionnelle. 🎜

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!