7、linux c 进程通信

一、无名管道（pipe）

1. 函数介绍

#include <unistd.h>
​
int pipe(int pfd[2]);

• 参数：pfd是一个包含两个整数的数组，pfd[0]为读描述符，pfd[1]为写描述符。

• 返回值：成功时返回0，失败时返回-1，并设置errno。

• 作用：创建一个无名管道，用于具有亲缘关系的进程间通信。

2. 特点

• 只能用于具有亲缘关系的进程间通信（父子进程、兄弟进程）。

• 单工通信，一端读，一端写。

• 数据自己读不能自己写。

• 管道可以用于大于2个进程共享。

3. 读写特性

读管道：

1. 管道中有数据：read返回实际读到的字节数。

2. 管道中无数据：

   • 写端被全部关闭，read返回0（像读到文件结尾）。

   • 写端未全部关闭，read阻塞等待。

写管道：

1. 管道读端全部被关闭：进程异常终止（可捕捉SIGPIPE信号避免终止）。

2. 管道读端未全部关闭：

   • 管道已满，write阻塞（管道大小64K）。

   • 管道未满，write将数据写入，并返回实际写入的字节数。

4. 示例代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
​
int main(void) {
    pid_t pid1, pid2;
    char buf[32];
    int pfd[2];
​
    // 创建管道
    if (pipe(pfd) < 0) {
        perror("pipe");
        exit(-1);
    }
​
    // 创建两个子进程
    pid1 = fork();
    if (pid1 == 0) {
        // 子进程1写入数据
        close(pfd[0]); // 关闭读端
        strcpy(buf, "I'm process 1");
        write(pfd[1], buf, 32);
        close(pfd[1]);
    } else {
        pid2 = fork();
        if (pid2 == 0) {
            // 子进程2写入数据
            close(pfd[0]); // 关闭读端
            strcpy(buf, "I'm process 2");
            write(pfd[1], buf, 32);
            close(pfd[1]);
        } else {
            // 父进程读取数据
            close(pfd[1]); // 关闭写端
            wait(NULL); // 等待子进程1结束
            read(pfd[0], buf, 32);
            printf("%s\n", buf);
            wait(NULL); // 等待子进程2结束
            read(pfd[0], buf, 32);
            printf("%s\n", buf);
            close(pfd[0]);
        }
    }
​
    return 0;
}

5. 小结

• 无名管道适用于亲缘进程间的单工通信。

• 创建时返回两个文件描述符，分别用于读写。

• 需要正确管理管道的读写端，避免阻塞和异常终止。

二、有名管道（fifo）

1. 函数介绍

#include <sys/types.h>
#include <sys/stat.h>
​
int mkfifo(const char *pathname, mode_t mode);

• 参数：

  • pathname：创建的管道文件路径。

  • mode：管道文件的权限，如0666。

• 返回值：成功时返回0，失败时返回-1。

• 作用：创建一个有名管道文件，用于非亲缘进程间通信。

2. 特点

• 可使非亲缘的两个进程互相通信。

• 通过路径名操作，在文件系统中可见，但内容存放在内存中。

• 使用文件IO操作。

• 遵循先进先出规则。

• 不支持lseek操作。

• 单工读写。

3. 创建与读写

创建有名管道

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
​
int main(void) {
    // 创建名为"myfifo"的有名管道，权限为0666
    if (mkfifo("myfifo", 0666) < 0) {
        perror("mkfifo");
        exit(-1);
    }
    return 0;
}

写入有名管道

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
​
#define N 32
​
int main(void) {
    char buf[N];
    int pfd;
​
    // 以只写方式打开有名管道
    if ((pfd = open("myfifo", O_WRONLY)) < 0) {
        perror("open");
        exit(-1);
    }
​
    while (1) {
        // 从键盘读取输入
        fgets(buf, N, stdin);
        // 输入"quit"时退出
        if (strcmp(buf, "quit\n") == 0) break;
        // 写入管道
        write(pfd, buf, N);
    }
​
    close(pfd);
    return 0;
}

读取有名管道

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
​
#define N 32
​
int main(void) {
    char buf[N];
    int pfd;
​
    // 以只读方式打开有名管道
    if ((pfd = open("myfifo", O_RDONLY)) < 0) {
        perror("open");
        exit(-1);
    }
​
    while (read(pfd, buf, N) > 0) {
        // 输出读取到的字符串长度
        printf("the length of string is %d\n", strlen(buf));
    }
​
    close(pfd);
    return 0;
}

4. 注意事项

• 不能以O_RDWR（读写）模式打开FIFO文件进行读写操作。

• O_NONBLOCK选项表示非阻塞，加上此选项后，open调用是非阻塞的。

• 对于以只读方式打开的FIFO文件，如果open调用是阻塞的，除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的，则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。

• 对于以只写方式打开的FIFO文件，如果open调用是阻塞的，open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的，open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。

• 如果有多个进程写同一个管道，使用O_WRONLY方式打开管道，如果写入的数据长度小于等于PIPE_BUF（4K），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。

5. 小结

• 有名管道适用于非亲缘进程间的单工通信。

• 需要先创建管道文件，再通过文件路径进行读写操作。

• 正确管理管道的打开方式和阻塞模式，确保通信正常进行。

三、内存映射

1.概念

内存映射是一种文件访问机制，它将磁盘上的文件与内存中的缓冲区进行映射，使得进程可以像访问普通内存一样对文件进行读写操作，而无需显式调用read和write函数。

2.mmap()函数的优点

• 实现了用户空间和内核空间的高效交互方式，减少了数据拷贝的次数，提高了程序的性能。

3.函数定义

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

• 功能：创建共享内存映射。

• 返回值：成功时返回创建的映射区首地址；失败时返回MAP_FAILED（((void *) -1)），并设置errno值。

• 参数说明：

  • addr：指定要映射的内存地址，一般设置为NULL，让操作系统自动选择合适的内存地址。

  • length：必须大于0。映射地址空间的字节数，从被映射文件开头offset个字节开始算起。

  • prot：指定共享内存的访问权限，可取值为PROT_READ（可读）、PROT_WRITE（可写）、PROT_EXEC（可执行）、PROT_NONE（不可访问）。

  • flags：由以下几个常量指定：MAP_SHARED（共享的）、MAP_PRIVATE（私有的）、MAP_FIXED（表示必须使用start参数作为开始地址，如果失败不进行修正）。其中，MAP_SHARED和MAP_PRIVATE必选其一，而MAP_FIXED不推荐使用。MAP_ANONYMOUS（匿名映射，用于血缘关系进程间通信）。

  • fd：表示要映射的文件句柄。如果匿名映射写-1。

  • offset：表示映射文件的偏移量，一般设置为0，表示从文件头部开始映射。

4.注意事项

1. 创建映射区的过程中，隐含着一次对映射文件的读操作，将文件内容读取到映射区。

2. 当MAP_SHARED时，要求映射区的权限应<=文件打开的权限（出于对映射区的保护），如果不满足报非法参数（Invalid argument）错误。当MAP_PRIVATE时，mmap中的权限是对内存的限制，只需要文件有读权限即可，操作只在内存有效，不会写到物理磁盘，且不能在进程间共享。

3. 映射区的释放与文件关闭无关，只要映射建立成功，文件可以立即关闭。

4. 用于映射的文件大小必须>0，当映射文件大小为0时，指定非0大小创建映射区，访问映射地址会报总线错误，指定0大小创建映射区，报非法参数错误（Invalid argument）。

5. 文件偏移量必须为0或者4K的整数倍（否则会报非法参数Invalid argument错误）。

6. 映射大小可以大于文件大小，但只能访问文件page的内存地址，否则报总线错误，超出映射的内存大小报段错误。

7. mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

5.mmap()映射的种类

1. 基于文件的映射：将文件内容映射到内存中，多个进程可以通过映射同一文件来共享内存。

2. 匿名映射：不与文件关联，适用于具有亲缘关系的进程之间通信。

6.释放内存映射

int munmap(void *addr, size_t length);

• 返回值：成功返回0，失败返回-1，并设置errno值。

• 参数：

  • addr：调用mmap函数成功返回的映射区首地址。

  • length：映射区大小（即mmap函数的第二个参数）。

7.示例

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>

int main() {
    const char *filename = "example.txt";
    const char *write_str = "Hello, mmap!";
    int fd;
    void *addr;
// 打开或创建一个文件，确保其大小足够进行映射
fd = open(filename, O_RDWR | O_CREAT, 0666);
if (fd == -1) {
    perror("open");
    exit(EXIT_FAILURE);
}

// 调整文件大小以容纳映射内容
if (ftruncate(fd, 4096) == -1) { // 将文件大小设置为一页（4096字节）
    perror("ftruncate");
    close(fd);
    exit(EXIT_FAILURE);
}

// 将文件映射到内存
addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (addr == MAP_FAILED) {
    perror("mmap");
    close(fd);
    exit(EXIT_FAILURE);
}

// 写入数据到映射区域
memcpy(addr, write_str, strlen(write_str) + 1); // 包含字符串结束符

// 从映射区域读取数据
printf("Read from memory: %s\n", (char *)addr);

// 同步映射区域的数据到文件（对于MAP_SHARED，通常不需要显式同步）
if (msync(addr, 4096, MS_SYNC) == -1) {
    perror("msync");
}

// 解除内存映射
if (munmap(addr, 4096) == -1) {
    perror("munmap");
    close(fd);
    exit(EXIT_FAILURE);
}

// 关闭文件描述符
close(fd);

return 0;
}

四、System V共享内存（过时）

1.概念

System V共享内存是一种高效的进程间通信方式，允许多个进程直接读写同一块内存区域，而无需进行数据拷贝。共享内存在内核空间创建，可被进程映射到用户空间访问，使用灵活。由于多个进程可同时访问共享内存，因此需要同步和互斥机制配合使用。

2.使用步骤

1. 生成key：使用ftok函数根据文件路径和项目ID生成一个唯一的key值。

2. 创建/打开共享内存：使用shmget函数创建新的共享内存或打开已有的共享内存。

3. 映射共享内存：使用shmat函数将共享内存映射到进程的地址空间，以便进行读写操作。

4. 读写共享内存：通过映射后的地址指针访问共享内存中的数据。

5. 撤销共享内存映射：使用shmdt函数撤销共享内存的映射，释放资源。

6. 删除共享内存对象：使用shmctl函数删除共享内存对象，确保资源被正确回收。

3.ftok函数

key_t ftok(const char *path, int proj_id);

• 功能：根据指定的文件路径和项目ID生成一个唯一的key值，用于标识System V IPC对象。

• 返回值：成功时返回合法的key值；失败时返回-1。

• 参数：

  • path：存在且可访问的文件的路径。

  • proj_id：用于生成key的数字，范围1-255。

4.shmget函数

int shmget(key_t key, int size, int shmflg);

• 功能：创建或打开一个共享内存段。

• 返回值：成功时返回共享内存的ID；失败时返回-1。

• 参数：

  • key：与共享内存关联的key值，可以是IPC_PRIVATE或由ftok生成。

  • size：共享内存的大小，以字节为单位。

  • shmflg：共享内存标志位，通常设置为IPC_CREAT|0666，其中0666表示权限。

5.shmat函数

void *shmat(int shmid, const void *shmaddr, int shmflg);

• 功能：将共享内存映射到进程的地址空间。

• 返回值：成功时返回映射后的地址；失败时返回(void *)-1。

• 参数：

  • shmid：要映射的共享内存ID。

  • shmaddr：映射后的地址，NULL表示由系统自动映射。

  • shmflg：标志位，0表示可读写；SHM_RDONLY表示只读。

6.shmdt函数

int shmdt(void *shmaddr);

• 功能：撤销共享内存的映射，释放资源。

• 返回值：成功时返回0；失败时返回-1。

• 参数：

  • shmaddr：映射后的地址指针。

7.shmctl函数

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

• 功能：对共享内存进行控制操作，如获取或设置共享内存属性、删除共享内存等。

• 返回值：成功时返回0；失败时返回-1。

• 参数：

  • shmid：要操作的共享内存ID。

  • cmd：要执行的操作，常见的有IPC_STAT（获取共享内存状态）、IPC_SET（设置共享内存属性）、IPC_RMID（删除共享内存）。

  • buf：保存或设置共享内存属性的地址。

8.示例代码

生成key

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    key_t key;
    if ((key = ftok(".", 'a')) == -1) {
        perror("ftok");
        exit(1);
    }
    printf("key: %d\n", key);
    return 0;
}

创建共享内存

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    key_t key = ftok(".", 'm');
    int shmid;
    if ((shmid = shmget(key, 1024, IPC_CREAT | 0666)) == -1) {
        perror("shmget");
        exit(1);
    }
    printf("Shared memory ID: %d\n", shmid);
    return 0;
}

映射共享内存并读写

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    key_t key = ftok(".", 'm');
    int shmid = shmget(key, 1024, 0666);
    char *addr = (char *)shmat(shmid, NULL, 0);
    if (addr == (char *)-1) {
        perror("shmat");
        exit(1);
    }
    printf("Enter a message: ");
    fgets(addr, 1024, stdin);
    printf("Message stored in shared memory: %s", addr);
    shmdt(addr);
    return 0;
}

删除共享内存

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    key_t key = ftok(".", 'm');
    int shmid = shmget(key, 1024, 0666);
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl");
        exit(1);
    }
    printf("Shared memory deleted.\n");
    return 0;
}

9.注意事项

• 每块共享内存大小有限制，可以通过ipcs -l或cat /proc/sys/kernel/shmmax查看。

• 共享内存删除的时间点：添加删除标记后，当nattach变成0时真正删除。