在Linux上创建进程通信的方法-猿码集

1. Linux进程通信简介

在Linux系统中，进程通信是指不同进程之间进行数据传输和信息交流的过程。进程通信允许不同的进程在同一个系统中协同工作并共享资源。常见的进程通信方式包括管道、信号、共享内存、消息队列等。

2. 管道

2.1 管道概述

管道是一种半双工的通信方式，它是由操作系统内核在内存中开辟的一个缓冲区，用于进程间的数据传输。管道可以分为匿名管道和命名管道两种类型。

匿名管道通常用于具有父子关系的进程间通信，通过使用pipe()系统调用创建管道：


int pipe(int pipefd[2]);

其中pipefd是一个包含两个整型变量的数组，分别代表管道的读端和写端。

命名管道则可以用于无关联的进程间通信，需要使用mkfifo命令创建管道文件，再通过open函数打开：


int mkfifo(const char *pathname, mode_t mode);
int open(const char *pathname, int flags);

2.2 管道示例

下面是一个使用匿名管道实现父子进程之间通信的示例：


#include <stdio.h>
#include <unistd.h>
int main() {
    int pipefd[2];
    char buf[BUFSIZ];
    pid_t pid;
    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }
    pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) {  // 子进程
        close(pipefd[1]);  // 关闭写端
        int n = read(pipefd[0], buf, sizeof(buf));
        printf("Child received message: %.*s\n", n, buf);
        close(pipefd[0]);
    } else {  // 父进程
        close(pipefd[0]);  // 关闭读端
        write(pipefd[1], "Hello, child!", 13);
        close(pipefd[1]);
    }
    return 0;
}

代码中首先使用pipe函数创建一个匿名管道，然后使用fork函数创建一个子进程。在子进程中，通过read函数从管道的读端读取数据；在父进程中，通过write函数向管道的写端写入数据。

3. 信号

3.1 信号概述

信号是一种软件中断，用于通知进程发生了某个事件。进程可以通过向另一个进程发送信号，实现进程之间的通信。Linux系统提供了一些常见的信号，如SIGINT(SIGTERM)，可以在终端中由键盘输入产生。

3.2 信号示例

下面是一个使用信号进行进程通信的示例：


#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void signalHandler(int signum) {
    printf("Received signal %d\n", signum);
}
int main() {
    signal(SIGUSR1, signalHandler);
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) {  // 子进程
        sleep(1);  // 等待父进程安装信号处理函数
        kill(getppid(), SIGUSR1);  // 向父进程发送信号
    } else {  // 父进程
        while (1) {
            // 处理其他任务...
        }
    }
    return 0;
}

代码中使用signal函数在父进程中安装了一个信号处理函数，当收到指定信号SIGUSR1时，将输出相应的提示信息。子进程在等待一段时间后，使用kill函数向父进程发送信号。

4. 共享内存

4.1 共享内存概述

共享内存是进程间共享内存区域的一种方式，使得多个进程可以直接访问和操作同一块内存空间。共享内存通常通过shmget、shmat和shmdt等函数来创建和使用。

4.2 共享内存示例

下面是一个简单的使用共享内存进行进程通信的示例：


#include <stdio.h>
#include <unistd.h>
#include <sys/shm.h>
#define SHM_SIZE 1024
int main() {
    int shmid;
    char *shmaddr;
    pid_t pid;
    shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        return 1;
    }
    pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) {  // 子进程
        shmaddr = shmat(shmid, NULL, 0);
        if (shmaddr == (char *)-1) {
            perror("shmat");
            return 1;
        }
        printf("Child read data: %s\n", shmaddr);
        shmdt(shmaddr);
    } else {  // 父进程
        shmaddr = shmat(shmid, NULL, 0);
        if (shmaddr == (char *)-1) {
            perror("shmat");
            return 1;
        }
        sprintf(shmaddr, "Hello, child!");
        shmdt(shmaddr);
        wait(NULL);  // 等待子进程退出
    }
    shmctl(shmid, IPC_RMID, NULL);  // 删除共享内存
    return 0;
}

代码中首先使用shmget函数创建一块共享内存区域，然后通过shmat函数将该共享内存连接到当前进程的地址空间。在父进程中，向共享内存写入数据；在子进程中，读取共享内存中的数据。

5. 消息队列

5.1 消息队列概述

消息队列是一种进程间通信机制，它允许进程通过在队列中放置和获取消息来进行通信。Linux系统中的消息队列使用msgget、msgsnd、msgrcv和msgctl等函数进行操作。

5.2 消息队列示例

下面是一个使用消息队列进行进程通信的示例：


#include <stdio.h>
#include <unistd.h>
#include <sys/msg.h>
struct msg {
    long type;
    char text[BUFSIZ];
};
int main() {
    int msgid;
    struct msg message;
    pid_t pid;
    msgid = msgget(IPC_PRIVATE, IPC_CREAT | 0666);
    if (msgid == -1) {
        perror("msgget");
        return 1;
    }
    pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) {  // 子进程
        sleep(1);  // 等待父进程发送消息
        msgrcv(msgid, &message, sizeof(message.text), 0, 0);
        printf("Child received message: %s\n", message.text);
    } else {  // 父进程
        strcpy(message.text, "Hello, child!");
        message.type = 1;
        msgsnd(msgid, &message, sizeof(message.text), 0);
        wait(NULL);  // 等待子进程退出
    }
    msgctl(msgid, IPC_RMID, NULL);  // 删除消息队列
    return 0;
}

代码中首先使用msgget函数创建一个消息队列，然后使用msgrcv和msgsnd函数分别在子进程和父进程中进行消息的接收和发送。

总结

本文介绍了在Linux上创建进程通信的几种方式，包括管道、信号、共享内存和消息队列。通过使用这些方法，可以实现不同进程之间的数据传输和信息交流，从而完成协同工作和资源共享的目标。在实际应用中，选择合适的进程通信方式需要考虑通信方式的特点和应用需求，以达到最佳的性能和效果。

在Linux上创建进程通信的方法