The principle of golang function and pipeline communication

Functions and pipes in Go language are used together to achieve inter-process communication. Functions can pass pipes as parameters to send or receive data through pipes. Pipes are unbuffered channels that can be used to send and receive data between goroutines and support both undirected and directed pipes. The

Principles and practices of function and pipeline communication in Go language

Introduction

Function and pipeline are the core components of Go language A powerful tool for inter-process communication (IPC) in . This article will delve into how they work and provide practical examples showing how to communicate using them.

Function

Function is a first-class citizen in Go language. It can pass data as parameters and return results. When a goroutine (lightweight thread) calls a function, the function runs within the goroutine's scope. Variables and resources can be passed between function calls.

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

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

Pipelines

Pipes are unbuffered channels used to send and receive data between goroutines. Pipes can be undirected or directed. Undirected pipes allow data to be sent in both directions between two goroutines, while directed pipes only allow one-way data flow.

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

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

Function and pipe communication

Functions and pipes can be used together for inter-process communication. By passing a pipe as a function parameter, a function can send or receive data through a pipe.

Send data

To send data to a pipe, you can use the operator (send operator). <code> The operator sends data to the pipe and blocks the sending goroutine until the data is received.

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

Receive data

To receive data from a pipe, you can use the operator (receive operator). <code> The operator receives data from the pipe and blocks the receiving goroutine until the data is available.

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

Practical case: Concurrent computation in pipelines

The following example shows how to use pipelines for concurrent computation:

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()
}

In this example, We send a range to the pipe, then in another goroutine we receive and print the data from the pipe. Unbuffered pipes ensure that send and receive operations are synchronized. Pipes provide a communication mechanism between two goroutines, enabling concurrent computation.

The above is the detailed content of The principle of golang function and pipeline communication. For more information, please follow other related articles on the PHP Chinese website!