正文

揭秘父进程与子进程的神秘数据交互：高效协作背后的秘密

/0 浏览量
0308

引言

在操作系统中，进程是执行程序的基本单位。当一个程序启动时，它会创建一个或多个进程。在这些进程中，父进程与子进程之间的数据交互是确保系统高效协作的关键。本文将深入探讨父进程与子进程之间的数据交互机制，揭示高效协作背后的秘密。

父进程与子进程的关系

在大多数操作系统中，进程可以创建子进程。父进程与子进程之间的关系可以用以下方式描述：

  • 父进程：启动子进程的进程。
  • 子进程：由父进程创建的进程。

父进程与子进程之间可以共享资源，如内存、文件描述符等。这种资源共享是实现高效数据交互的基础。

数据交互方式

父进程与子进程之间的数据交互主要有以下几种方式：

1. 管道（Pipe）

管道是一种简单的进程间通信（IPC）机制。它允许两个相关联的进程之间进行单向数据传输。在父进程与子进程之间，管道通常用于从父进程向子进程传递数据。

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    int pipefd[2];
    pid_t cpid;

    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (cpid == 0) { // 子进程
        close(pipefd[1]); // 关闭管道的写端
        char buffer[1024];
        read(pipefd[0], buffer, sizeof(buffer)); // 读取数据
        printf("Received: %s\n", buffer);
        close(pipefd[0]); // 关闭管道的读端
        exit(EXIT_SUCCESS);
    } else { // 父进程
        close(pipefd[0]); // 关闭管道的读端
        write(pipefd[1], "Hello, child!\n", 16); // 写入数据
        close(pipefd[1]); // 关闭管道的写端
        wait(NULL); // 等待子进程结束
    }

    return 0;
}

2. 命名管道（Named Pipe）

命名管道是一种更为复杂的IPC机制，它允许不相关联的进程之间进行数据传输。在父进程与子进程之间，命名管道可以用于在不同进程间共享数据。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/wait.h>

int main() {
    int pipe_fd;
    pid_t cpid;

    // 创建命名管道
    if (mkfifo("myfifo", 0666) == -1) {
        perror("mkfifo");
        exit(EXIT_FAILURE);
    }

    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (cpid == 0) { // 子进程
        close(STDOUT_FILENO);
        dup2(pipe_fd, STDOUT_FILENO); // 将标准输出重定向到命名管道
        execlp("echo", "echo", "Hello, parent!", (char *)NULL);
        perror("execlp");
        exit(EXIT_FAILURE);
    } else { // 父进程
        close(pipe_fd);
        wait(NULL); // 等待子进程结束
        FILE *fp = fopen("myfifo", "r");
        char buffer[1024];
        if (fgets(buffer, sizeof(buffer), fp) != NULL) {
            printf("Received: %s\n", buffer);
        }
        fclose(fp);
        unlink("myfifo"); // 删除命名管道
    }

    return 0;
}

3. 套接字（Socket）

套接字是一种更为通用的IPC机制，它允许不同主机上的进程进行通信。在父进程与子进程之间，套接字可以用于跨网络的数据传输。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>

int main() {
    int sock_fd;
    struct sockaddr_in serv_addr, cli_addr;
    socklen_t cli_addr_len;
    pid_t cpid;

    // 创建套接字
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 绑定套接字
    if (bind(sock_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 监听套接字
    if (listen(sock_fd, 5) == -1) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (cpid == 0) { // 子进程
        int new_sock_fd;
        socklen_t new_cli_addr_len;
        char buffer[1024];

        new_sock_fd = accept(sock_fd, (struct sockaddr *)&cli_addr, &new_cli_addr_len);
        if (new_sock_fd == -1) {
            perror("accept");
            exit(EXIT_FAILURE);
        }

        read(new_sock_fd, buffer, sizeof(buffer));
        printf("Received: %s\n", buffer);
        close(new_sock_fd);
        exit(EXIT_SUCCESS);
    } else { // 父进程
        close(sock_fd);
        wait(NULL); // 等待子进程结束
    }

    return 0;
}

总结

父进程与子进程之间的数据交互是操作系统高效协作的关键。本文介绍了管道、命名管道和套接字这三种常用的数据交互方式。在实际应用中，开发者可以根据具体需求选择合适的方式来实现进程间的数据交互。

-- 展开阅读全文 --