Comment utiliser les canaux nommés dans Go ?

Les canaux nommés sont une méthode de communication de processus de niveau relativement bas dans le système d'exploitation. Il s'agit d'une méthode de communication de processus qui utilise des fichiers comme intermédiaire. Dans le langage Go, la prise en charge des canaux nommés est fournie via le package os. Dans cet article, nous expliquerons comment utiliser les canaux nommés pour la communication inter-processus dans Go.

1. Le concept de tubes nommés

Un tube nommé est un fichier spécial accessible par plusieurs processus en même temps. Dans les systèmes Linux, les canaux nommés sont un type de fichier spécial qui existe quelque part sur le système de fichiers et peut être partagé entre différents processus. Les canaux nommés peuvent être utilisés pour transférer des données entre différents processus. Étant donné que les canaux nommés sont des fichiers sur un système de fichiers, ils peuvent être utilisés pour communiquer entre tous les processus ayant accès au système de fichiers.

2. Principes de base de l'utilisation des canaux nommés dans Go

Dans le langage Go, la méthode pour se connecter aux canaux nommés consiste à utiliser les fonctions du package os. Les canaux nommés sont ouverts et fermés à l’aide des fonctions correspondantes dans le package os. Les processus peuvent partager un fichier de canal nommé en le transmettant à d'autres processus, et tout autre processus qui accède au fichier de canal nommé peut lire et écrire des données.

3. Utilisez des canaux nommés pour communiquer entre deux processus Go

Il est très simple d'utiliser des canaux nommés pour communiquer entre deux processus Go. Nous allons écrire ici deux programmes Go, l'un d'eux écrira un message dans le canal nommé et l'autre programme lira le message du canal nommé et l'imprimera.

1. Exemple de code-1 : écriture dans un canal nommé

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!")
}

À la ligne 5, nous définissons une constante fifo pour représenter le chemin où se trouve le fichier de canal nommé. Ensuite, à la ligne 6, nous définissons le message à écrire dans le tube. Ensuite, nous ouvrirons le fichier de canal nommé et écrirons le message dans le canal. À la ligne 11, nous utilisons la fonction os.OpenFile() pour ouvrir le fichier tube nommé et l'option os.O_WRONLY pour ouvrir le fichier en mode écriture seule. Ensuite, à la ligne 15, nous utilisons la fonction pipeout.WriteString() pour écrire le message dans le canal nommé. fifo表示命名管道文件所在的路径。然后，在第6行中，我们定义了要写入到管道中的消息。下面，我们将打开命名管道文件，并将消息写入管道中。在第11行中，我们使用os.OpenFile()函数打开命名管道文件，并使用os.O_WRONLY选项以只写模式打开文件。接下来，在第15行中，我们使用pipeout.WriteString()函数将消息写入到命名管道中。

2. 代码示例-2：从命名管道中读取并打印消息

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

在第5行中，我们定义了一个常量fifo表示命名管道文件所在的路径。然后，在第6行中，我们定义了一个byte数组msg，用于存储从管道中读取的消息。下面，我们将打开命名管道文件，并从管道中读取消息。在第11行中，我们使用os.OpenFile()函数打开命名管道文件，并使用os.O_RDONLY选项以只读模式打开文件。接下来，在第17行中，我们使用pipein.Read()函数从命名管道中读取消息，并将其存储到msg

Exemple de code-2 : Lecture et impression de messages à partir d'un tube nommé
rrreee

Dans la ligne 5, nous définissons une constante fifo pour représenter un tube nommé Le chemin où se trouve le fichier. Ensuite, à la ligne 6, nous définissons un tableau d'octets msg pour stocker le message lu dans le tube. Ensuite, nous ouvrirons le fichier de canal nommé et lirons les messages du canal. À la ligne 11, nous utilisons la fonction os.OpenFile() pour ouvrir le fichier tube nommé et l'option os.O_RDONLY pour ouvrir le fichier en mode lecture seule. Ensuite, à la ligne 17, nous utilisons la fonction pipein.Read() pour lire le message du canal nommé et le stocker dans le tableau msg. Enfin, à la ligne 19, nous imprimons le message que nous avons reçu.

🎜4. Résumé🎜🎜Cet article présente la méthode d'utilisation de canaux nommés pour réaliser une communication inter-processus en langage Go. Nous avons écrit deux programmes Go, dont l'un écrit des messages dans le canal nommé et l'autre programme lit les messages du canal nommé et les imprime. Il convient de noter que lors de l'utilisation de canaux nommés, chaque processus doit négocier l'ordre dans lequel les canaux sont utilisés, sinon cela provoquerait des conflits de lecture et d'écriture, provoquant le blocage du programme. 🎜

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!