How golang functions use pipes to communicate

In Go, a pipe is a FIFO queue used for communication between goroutines. Create a pipeline: use the make(chan T) function, where T is the data type in the pipeline. Sending data: Use the ch

Use pipes for function communication in Go

In Go, pipes are a lightweight communication mechanism. Allows goroutines (Go coroutines) to exchange data safely and efficiently. A pipe is essentially a FIFO (first in, first out) queue through which goroutines can send and receive data.

Create pipeline

The pipeline is created using the make(chan T) function, where T is the data carried in the pipeline type. The following example creates a channel that contains data of type string:

ch := make(chan string)

Send data

To send data to the pipe, use ch &lt ;- data syntax, where <code>ch is the pipe to send the data to and data is the value to send.

ch <- "Hello, World!"

Receive data

To receive data from a pipe, use the syntax, where <code>ch is The pipe to receive data from.

message := <-ch

Practical case: Concurrent file reading

Let us create a file reading program that uses pipe concurrency. The program will read data from multiple files and send it to a pipe, and another goroutine will receive the data from the pipe and print it to the console.

package main

import (
    "bufio"
    "fmt"
    "io/ioutil"
    "log"
    "os"
)

func readFile(filePath string, ch chan string) {
    file, err := os.Open(filePath)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        ch <- scanner.Text()
    }
}

func main() {
    ch := make(chan string)

    // 从多个文件中读取数据
    files := []string{"file1.txt", "file2.txt", "file3.txt"}
    for _, file := range files {
        go readFile(file, ch)
    }

    // 从管道接收并打印数据
    for {
        message := <-ch
        if message == "" {
            break
        }
        fmt.Println(message)
    }
}

In this example, we create a pipe ch that will hold the lines read from the file. Three goroutines concurrently read data from different files and send it to the pipe. Another goroutine receives data from the pipe and prints it to the console.

The above is the detailed content of How golang functions use pipes to communicate. For more information, please follow other related articles on the PHP Chinese website!