Le principe de la fonction Golang et de la communication pipeline

Les fonctions et les tuyaux du langage Go sont utilisés ensemble pour réaliser une communication inter-processus. Les fonctions peuvent transmettre des tubes en tant que paramètres pour envoyer ou recevoir des données via des tubes. Les tuyaux sont des canaux sans tampon qui peuvent être utilisés pour envoyer et recevoir des données entre des goroutines et prendre en charge les tuyaux non dirigés et dirigés. L'opérateur

Principes et pratique de la communication par fonction et canal en langage Go

Introduction

La fonction et le canal sont des outils puissants pour la communication inter-processus (IPC) en langage Go. Cet article expliquera leur fonctionnement et fournira des exemples pratiques montrant comment communiquer en les utilisant.

Function

Function est un citoyen de première classe en langage Go, qui peut transmettre des données en tant que paramètres et renvoyer des résultats. Lorsqu'un goroutine (thread léger) appelle une fonction, la fonction s'exécute dans la portée du goroutine. Les variables et les ressources peuvent être transmises entre les appels de fonction.

func add(x, y int) int {
    return x + y
}

func main() {
    result := add(10, 20)
    fmt.Println(result) // 输出：30
}

Pipelines

Les pipelines sont des canaux sans tampon utilisés pour envoyer et recevoir des données entre goroutines. Les tuyaux peuvent être non dirigés ou dirigés. Les tuyaux non dirigés permettent aux données d'être envoyées dans les deux sens entre deux goroutines, tandis que les tuyaux dirigés permettent uniquement un flux de données unidirectionnel.

// 无向管道
unbufferedChan := make(chan int)

// 有向管道
bufferedChan := make(chan int, 10) // 缓冲区大小为 10

Communication entre fonctions et tuyaux

Les fonctions et les tuyaux peuvent être utilisés ensemble pour la communication inter-processus. En passant un tube en tant que paramètre de fonction, une fonction peut envoyer ou recevoir des données via un tube.

Envoi de données

Pour envoyer des données vers un tube, vous pouvez utiliser l'opérateur <- (opérateur d'envoi). L'opérateur <- envoie des données à un tube et bloque la goroutine d'envoi jusqu'à ce que les données soient reçues. <- 操作符（发送运算符）。<- 操作符将数据发送到管道，并阻塞发送 goroutine，直到数据被接收。

func sendData(ch chan int) {
    ch <- 100
}

接收数据

要从管道接收数据，可以使用 <- 操作符（接收运算符）。<-

func receiveData(ch chan int) {
    data := <-ch
    fmt.Println(data) // 输出：100
}

Recevoir des données

Pour recevoir des données d'un canal, vous pouvez utiliser l'opérateur <- (opérateur de réception). L'opérateur <- reçoit les données d'un tube et bloque la goroutine de réception jusqu'à ce que les données soient disponibles.

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建无缓冲管道
    ch := make(chan int)
    var wg sync.WaitGroup

    // 创建 goroutine 发送数据到管道
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch) // 关闭管道，表示没有更多数据
    }()

    // 创建 goroutine 从管道接收数据
    wg.Add(1)
    go func() {
        defer wg.Done()
        for data := range ch {
            fmt.Println(data)
        }
    }()

    // 等待所有 goroutine 完成
    wg.Wait()
}

Exemple pratique : calculs simultanés dans des pipelines

🎜🎜L'exemple suivant montre comment utiliser des pipelines pour des calculs simultanés : 🎜rrreee🎜Dans cet exemple, nous envoyons une plage au pipeline puis depuis le pipeline dans une autre goroutine Recevez et imprimer des données. Les canaux sans tampon garantissent que les opérations d'envoi et de réception sont synchronisées. Les tuyaux fournissent un mécanisme de communication entre deux goroutines, permettant des calculs simultanés. 🎜

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!