How to use named pipes in Go?

Named pipes are a relatively low-level process communication method in the operating system. It is a process communication method that uses files as an intermediary. In the Go language, support for named pipes is provided through the os package. In this article, we will introduce how to use named pipes for inter-process communication in Go.

1. The concept of named pipe

A named pipe is a special file that can be accessed by multiple processes at the same time. In Linux systems, named pipes are a special file type that exist somewhere in the file system and can be shared between different processes. Named pipes can be used to transfer data between different processes. Because named pipes are files on a file system, they can be used to communicate between all processes that have access to the file system.

2. Basic principles of using named pipes in Go

In the Go language, the way to connect to a named pipe is by using the functions in the os package. Named pipes are opened and closed using the corresponding functions in the os package. Processes can share a named pipe file by passing it to other processes, and any other process that accesses the named pipe file can read and write data.

3. Use named pipes to communicate between two Go processes

It is very simple to use named pipes to communicate between two Go processes. We will write two Go programs here, one of them will write a message to the named pipe and the other program will read the message from the named pipe and print it out.

1. Code Example-1: Writing to a Named Pipe

package main

import (
    "fmt"
    "os"
)

func main() {
    fifo := "/tmp/myfifo" // 命名管道文件路径
    msg := "Hello World!" // 要写入管道的消息

    // 打开管道文件
    pipeout, err := os.OpenFile(fifo, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
    if err != nil {
        fmt.Println("Error: ", err)
        return
    }
    defer pipeout.Close()

    // 写入消息到管道
    _, err = pipeout.WriteString(msg)
    if err != nil {
        fmt.Println("Error: ", err)
        return
    }

    fmt.Println("Message sent to named pipe!")
}

In line 5, we define a constant fifo to represent a named pipe The path where the file is located. Then, on line 6, we define the message to be written to the pipe. Next, we will open the named pipe file and write the message to the pipe. In line 11, we open the named pipe file using the os.OpenFile() function and the os.O_WRONLY option to open the file in write-only mode. Next, in line 15, we use the pipeout.WriteString() function to write the message to the named pipe.

2. Code Example-2: Reading and printing messages from a named pipe

package main

import (
    "fmt"
    "os"
)

func main() {
    fifo := "/tmp/myfifo" // 命名管道文件路径
    msg := make([]byte, 1024)

    // 打开管道文件
    pipein, err := os.OpenFile(fifo, os.O_RDONLY, 0)
    if err != nil {
        fmt.Println("Error: ", err)
        return
    }
    defer pipein.Close()

    // 读取消息从管道
    n, err := pipein.Read(msg)
    if err != nil {
        fmt.Println("Error: ", err)
        return
    }

    fmt.Println("Message received from named pipe: ", string(msg[:n]))
}

In line 5, we define a constant fifoIndicates the path where the named pipe file is located. Then, in line 6, we define a byte array msg to store the message read from the pipe. Next, we will open the named pipe file and read messages from the pipe. In line 11, we open the named pipe file using the os.OpenFile() function and open the file in read-only mode using the os.O_RDONLY option. Next, in line 17, we use the pipein.Read() function to read the message from the named pipe and store it into the msg array. Finally, on line 19, we print out the message we received.

4. Summary

This article introduces the method of using named pipes to achieve inter-process communication in the Go language. We wrote two Go programs, one of which writes messages to a named pipe, and the other program reads messages from the named pipe and prints them out. It is worth noting that when using named pipes, each process should negotiate the order in which the pipes are used, otherwise it will cause read and write conflicts, causing the program to crash.

The above is the detailed content of How to use named pipes in Go?. For more information, please follow other related articles on the PHP Chinese website!