Linux管道通信C语言编程示例

我们来详细讲解一下“Linux管道通信C语言编程示例”的完整攻略。

什么是Linux管道通信

Linux管道通信是一种进程间通信方式，它通过特殊的管道文件连接两个或多个进程，使数据在进程之间传递。简单来说，就是在两个进程之间建立一个管道，让它们可以通过这个管道进行数据交换。

管道通信C语言编程示例

下面我们就来看一下管道通信的C语言编程示例。这里我们介绍两个示例说明。

示例一

首先我们看一个简单的示例，它创建一个子进程，然后在子进程中往管道中写入数据，父进程从管道中读取数据。示例代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define BUFFER_SIZE 25

int main() {
    char write_msg[BUFFER_SIZE] = "Hello, World!";
    char read_msg[BUFFER_SIZE];
    int fd[2];
    pid_t pid;

    /* create the pipe */
    if (pipe(fd) == -1) {
        fprintf(stderr, "Pipe failed");
        return 1;
    }

    /* fork a child process */
    pid = fork();

    if (pid < 0) {
        fprintf(stderr, "Fork failed");
        return 1;
    }

    if (pid > 0) {
        /* parent process */
        close(fd[1]); /* close the write end of the pipe */

        /* read from the pipe */
        read(fd[0], read_msg, BUFFER_SIZE);
        printf("Parent read from pipe: %s", read_msg);

        /* close the read end of the pipe */
        close(fd[0]);
    } else {
        /* child process */
        close(fd[0]); /* close the read end of the pipe */

        /* write to the pipe */
        write(fd[1], write_msg, BUFFER_SIZE);

        /* close the write end of the pipe */
        close(fd[1]);
    }

    return 0;
}

运行以上代码，会输出“Parent read from pipe: Hello, World!”，说明子进程已经将数据写入到了管道中，父进程从管道中读取到了这个数据。

示例二

接下来我们看一个稍微复杂一些的示例，它创建两个子进程，一个子进程往管道中写入数据，另一个子进程从管道中读取数据，并对读取的数据进行处理。示例代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 25

void child_write(int write_fd, char *write_msg) {
    write(write_fd, write_msg, BUFFER_SIZE);
}

void child_read(int read_fd) {
    char read_msg[BUFFER_SIZE];
    int num_read = read(read_fd, read_msg, BUFFER_SIZE);
    if (num_read <= 0) {
        fprintf(stderr, "Read failed");
        return;
    }
    printf("Child read from pipe: %s", read_msg);
}

void child_process(int read_fd, int write_fd) {
    close(read_fd); /* close the read end of the pipe */
    char *write_msg = "Hello, World!";
    child_write(write_fd, write_msg);
    close(write_fd); /* close the write end of the pipe */
}

void parent_process(int read_fd, int write_fd) {
    close(write_fd); /* close the write end of the pipe */
    child_read(read_fd);
    close(read_fd); /* close the read end of the pipe */
}

int main() {
    int fd[2];
    pid_t pid1, pid2;

    /* create the pipe */
    if (pipe(fd) == -1) {
        fprintf(stderr, "Pipe failed");
        return 1;
    }

    /* fork child process 1 */
    pid1 = fork();

    if (pid1 < 0) {
        fprintf(stderr, "Fork failed");
        return 1;
    }

    if (pid1 == 0) {
        /* child process 1 */
        child_process(fd[0], fd[1]);
        exit(0);
    } else {
        /* parent process */
        /* fork child process 2 */
        pid2 = fork();

        if (pid2 < 0) {
            fprintf(stderr, "Fork failed");
            return 1;
        }

        if (pid2 == 0) {
            /* child process 2 */
            child_read(fd[0]);
            exit(0);
        } else {
            /* parent process */
            parent_process(fd[0], fd[1]);
            wait(NULL);
            wait(NULL);
        }
    }

    return 0;
}

运行以上代码，会输出“Child read from pipe: Hello, World!”，说明第一个子进程已经将数据写入到了管道中，第二个子进程从管道中读取到了这个数据，并对它进行了处理。

总结

Linux管道通信是一种方便、高效的进程间通信方式，C语言编程示例演示了管道的创建、数据的读写等基本操作。在实际开发中，我们可以根据具体的需求采用不同的进程间通信方式。