Linux父子进程间的通信实践-猿码集

Linux父子进程间的通信实践

在Linux操作系统中，父子进程之间的通信是一种非常重要且常见的需求。父子进程之间的通信可以通过多种方式实现，例如管道、信号、共享内存等。本文将介绍如何使用这些方式在Linux中实现父子进程间的通信，并通过实际案例来展示其应用。

1. 管道

管道是一种用于实现进程间通信的机制，其特点是一端写入数据，另一端读取数据。在Linux中，可以使用pipe()函数创建一个管道，并使用fork()函数创建父子进程，从而实现父子进程间的通信。

以下是一个使用管道实现进程间通信的示例：


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
    int fd[2];
    char buf[256];
    
    // 创建管道
    if (pipe(fd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    
    pid_t pid = fork();
    
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程
        close(fd[0]); // 关闭读端
        write(fd[1], "Hello, parent!", 14);
        close(fd[1]);
        exit(EXIT_SUCCESS);
    } else {
        // 父进程
        close(fd[1]); // 关闭写端
        read(fd[0], buf, sizeof(buf));
        printf("Received message from child: %s\n", buf);
        close(fd[0]);
        exit(EXIT_SUCCESS);
    }
}

在上述代码中，创建了一个管道fd，并使用fork()函数创建了一个父进程和一个子进程。父进程负责向管道写入数据，子进程负责从管道读取数据，实现了父子进程间的通信。

2. 信号

信号是一种用于进程间通信的机制，通过向目标进程发送信号来实现进程间的通信。在Linux中，可以使用signal()函数来注册信号处理函数，从而实现父子进程间的通信。

以下是一个使用信号实现进程间通信的示例：


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
volatile int flag = 0;
void sig_handler(int signo) {
    if (signo == SIGUSR1) {
        flag = 1;
    }
}
int main() {
    pid_t pid = fork();
    
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程
        signal(SIGUSR1, sig_handler); // 注册信号处理函数
        
        while (!flag) {
            // 子进程等待信号到来
        }
        
        printf("Received signal from parent!\n");
        exit(EXIT_SUCCESS);
    } else {
        // 父进程
        sleep(1); // 等待子进程注册信号处理函数
        
        printf("Sending signal to child...\n");
        kill(pid, SIGUSR1); // 向子进程发送信号
        
        wait(NULL); // 等待子进程退出
        exit(EXIT_SUCCESS);
    }
}

在上述代码中，使用kill()函数向子进程发送SIGUSR1信号，子进程收到信号后，flag变量被设置为1，从而实现了父子进程间的通信。

3. 共享内存

共享内存是一种可以让多个进程共享同一块物理内存的机制。在Linux中，可以使用shmget()函数创建一个共享内存，使用shmat()函数将共享内存映射到进程的虚拟地址空间，从而实现父子进程间的通信。

以下是一个使用共享内存实现进程间通信的示例：


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int main() {
    int shmid;
    char *shmaddr;
    
    // 创建共享内存
    shmid = shmget(IPC_PRIVATE, 1024, IPC_CREAT | 0644);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    
    pid_t pid = fork();
    
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程
        shmaddr = shmat(shmid, NULL, 0);
        if (shmaddr == (char *)-1) {
            perror("shmat");
            exit(EXIT_FAILURE);
        }
        
        sprintf(shmaddr, "Hello, parent!"); // 写入共享内存
        
        exit(EXIT_SUCCESS);
    } else {
        // 父进程
        sleep(1); // 等待子进程写入共享内存
        
        shmaddr = shmat(shmid, NULL, 0);
        if (shmaddr == (char *)-1) {
            perror("shmat");
            exit(EXIT_FAILURE);
        }
        
        printf("Received message from child: %s\n", shmaddr);
        
        shmdt(shmaddr); // 解除共享内存映射
        shmctl(shmid, IPC_RMID, NULL); // 删除共享内存
        
        exit(EXIT_SUCCESS);
    }
}

在上述代码中，使用shmget()函数创建了一个共享内存，shmaddr指针指向了共享内存的起始地址。父子进程通过shmaddr指针对共享内存进行读写操作，实现了进程间的通信。

总结

本文介绍了Linux环境下父子进程间通信的三种主要方式：管道、信号和共享内存。管道适合于一对一的父子进程通信，信号适合于一对多的父子进程通信，共享内存适合于多对多的父子进程通信。选择不同的通信方式应根据具体需求来确定。

管道通过pipe()函数创建，使用write()函数向管道写入数据，使用read()函数从管道读取数据。信号通过kill()函数发送信号，使用signal()函数注册信号处理函数。共享内存通过shmget()函数创建，使用shmat()函数将共享内存映射到进程的虚拟地址空间，使用shmdt()函数解除共享内存映射。

对于不同的通信方式，需要根据具体情况选择合适的机制进行实现。使用管道可以实现简单的数据传输；使用信号可以进行一些简单的通知和响应；使用共享内存可以实现高效的数据共享。掌握这些通信方式，可以在Linux环境下更好地实现父子进程间的通信。

Linux父子进程间的通信实践