文章目录
1. 前言
限于作者能力水平，本文可能存在谬误，因此而给读者带来的损失，作者不做任何承诺。
2. 进程间通信机制
进程间通信机制，简称 IPC(InterProcess Communication)。
2.1 管道
管道特性：
1. 半双工，数据是单向流动。
2. 只能在有共同祖先的进程间使用。
3. 数据一旦被读走，便不在管道中存在，不可反复读取。
2.1.1 匿名管道
可通过系统调用 pipe() 创建匿名管道：
pipe() 调用返回两个文件句柄：filedes[0] 用于读，filedes[1] 用于写。用于读的句柄在所有数据被读取后，继续读返回0指示达到数据末尾；如果管道读端的 filedes[0] 关闭了，再向管道写端的 filedes[1] 写入，会产生 SIGPIPE 信号。
例子代码：
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int main(void)
{
int n, fd[2];
pid_t pid;
char buf[4096];
if (pipe(fd)) {
perror("pipe");
exit(EXIT_FAILURE);
}
pid = fork();
if (pid < 0) {
perror("fork");
exit(EXIT_FAILURE);
}
if (pid > 0) { /* 父进程 */
close(fd[0]); /* 父进程关闭读端 */
write(fd[1], "hello, child, i'm your father.\n", 31);
} else if (pid == 0) { /* 子进程 */
close(fd[1]); /* 子进程关闭写端 */
n = read(fd[0], buf, sizeof(buf));
write(STDOUT_FILENO, buf, n);
}
return 0;
}例子中，管道数据流向是 父进程 -> 子进程，我们也完全可以通过关闭父进程的写端和子进程的读端，创建数据流向完全相反的管道。
2.1.2 popen() 和 pclose()
前述匿名管道方式使用起来不是很方便，这时候可以使用 popen() ：
函数 popen() 先执行 fork() ，然后调用 exec() 执行 cmdstring 参数指向的程序，最后返回一个标准 I/O 的文件对象指针。
如果 type 参数是 "r" ，则文件对象指针连接到 cmdstring 参数指向程序的标准输出：
也就是 cmdstring 参数指向程序所在子进程，通过管道将其标准输出数据传递给父进程。
如果 type 参数是 "w" ，则文件对象指针连接到 cmdstring 参数指向程序的标准输入：
也就是 cmdstring 参数指向程序所在子进程的标准输入，通过管道从父进程读取。
说白了，本质上 popen() 就是对 pipe() 的封装，提高了使用的便利性。
看一个 popen() 使用的例子：
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int main(int argc, char *argv[])
{
FILE *fp;
char buf[4096] = {0};
int n;
fp = popen("/bin/ls -l", "r");
if (!fp) {
perror("popen");
exit(EXIT_FAILURE);
}
n = fread(buf, 1, sizeof(buf), fp);
printf("%d bytes\n%s\n", n, buf);
pclose(fp);
return 0;
}2.1.3 命名管道 FIFO
前述的管道方式，只能用于有亲缘关系的进程，不相关的进程之间，可以使用命名管道(FIFO)进行数据传输。通过函数 mkfifo() 创建命名管道(FIFO)：
一旦创建了命名管道(FIFO)文件，就可以通过 open() 打开它，然后进行 read(), write(), close()，unlink() 等操作。
类似于匿名管道，在没有读端进程打开命名管道文件时，如果写端进程对命名管道(FIFO)进行写操作，则会产生 SIGPIPE 信号。
多个进程写同一个命名管道(FIFO)，这是很常见的情形，如果不想各进程写入的数据相互穿插，就需要考虑同步问题。
命名管道(FIFO)常见用途如下：
1. shell命令间相互传递数据。
2. 客户/服务端程序，以便客户进程和服务端进程之间传递数据。看一个例子：
/* FIFO 写端程序：fifo_wend.c */
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include "fifo_test.h"
int main(void)
{
int fd;
char s[] = "hello!\n";
fd = open(FIFO_FILE, O_WRONLY);
write(fd, s, sizeof(s));
close(fd);
return 0;
}/* FIFO 读端程序：fifo_rend.c */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include "fifo_test.h"
int main(void)
{
char buf[4096];
int fd;
fd = open(FIFO_FILE, O_RDONLY);
read(fd, buf, sizeof(buf));
close(fd);
printf("%s", buf);
return 0;
}公共头文件 fifo_test.h ：
#define FIFO_FILE "fifo"编译和运行：
$ make fifo_rend fifo_wend
$ mkfifo fifo 创建 FIFO 命名管道文件 fifo
$ ./fifo_rend 先启动读端程序
$ ./fifo_wend 后启动写端程序
$ rm fifo 测试完成后删除 fifo 文件读端程序 fifo_rend 会输出 hello! 字串。
2.2 消息队列
管道的方式虽然简单，但是比较低效，不适合进程间频繁的数据交流，并且管道只能传输无格式字节流。对于进程间频繁的数据交流，如果要求高效、带有格式，使用消息队列将会是更好的选择。消息队列的数据在进程间的流动如下图(图片取自参考资料中知乎博文)：
创建消息队列函数 msgget() ：
更多细节参考 https://man7.org/linux/man-pages/man2/msgget.2.html 。
配置消息队列函数 msgctl() ：
更多细节参考 https://man7.org/linux/man-pages/man2/msgctl.2.html 。
发送数据到消息队列函数 msgsnd() ：
更多细节参考 https://man7.org/linux/man-pages/man2/msgsnd.2.html 。
从消息队列获取数据函数 ：
更多细节参考 https://man7.org/linux/man-pages/man2/msgrcv.2.html 。
看一个例子，包含消息发送和接收两个程序。程序公共头文件 msg_test.h ：
#define MSGQ_ID 1234
#define MSG_END "<END>"
#define MAX_TEXT 4096
struct msg_data {
long int msg_type;
char text[MAX_TEXT];
};消息发送程序代码 msg_snd.c ：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/msg.h>
#include <errno.h>
#include "msg_test.h"
int main(int argc, char **argv)
{
struct msg_data data;
int msgid = -1;
static const char *msg_text[] = {
"message 001",
"message 002",
"message 003",
MSG_END
};
int i;
/* create */
msgid = msgget((key_t)MSGQ_ID, 0666 | IPC_CREAT);
if (msgid == -1) {
perror("msgget");
exit(EXIT_FAILURE);
}
for (i = 0; i < sizeof(msg_text)/sizeof(msg_text[0]); i++) {
data.msg_type = 1;
strcpy(data.text, msg_text[i]);
if (msgsnd(msgid, (void *)&data, MAX_TEXT, 0) == -1) { /* send text message */
perror("msgsnd");
exit(EXIT_FAILURE);
}
}
return 0;
}消息接收程序代码 msg_rcv.c ：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/msg.h>
#include <errno.h>
#include "msg_test.h"
int main(int argc, char **argv)
{
int msgid = -1;
struct msg_data data;
long int msgtype = 0;
msgid = msgget((key_t)MSGQ_ID, 0666 | IPC_CREAT);
if (msgid == -1) {
perror("msgget");
exit(EXIT_FAILURE);
}
for (;;) {
if (msgrcv(msgid, (void *)&data, MAX_TEXT, msgtype, 0) == -1) {
perror("msgrcv");
exit(EXIT_FAILURE);
}
printf("<MESSAGE>: %s\n", data.text);
if (strcmp(data.text, MSG_END) == 0)
break;
}
/* remove */
if (msgctl(msgid, IPC_RMID, 0) == -1) {
perror("msgget");
exit(EXIT_FAILURE);
}
return 0;
}编译和运行：
$ make msg_snd msg_rcv
$ ./msg_rcv
$ ./msg_snd当然，消息队列也可用于父子进程间的通信，感兴趣的读者可以自行实践。
2.3 共享内存
为了避免消息队列那样频繁的数据拷贝，以及系统调用开销，引入了共享内存 IPC 机制。
共享内存 允许两个或更多进程共享一块物理内存区域，因为数据不需要在进程间来回拷贝，所以这是本文所有 IPC 机制中最快的一种。共享内存的各进程页表结构如下图(图片取自参考资料中知乎博文)：
上图告诉我们，共享内存的物理区域是相同的，进程使用各自页表项映射到相同的物理内存块。也可以从另一个视角来理解(图片取自参考资料中CSDN博文)：
这里更清晰的看到，共享内存的物理内存区，在进程中对应的虚拟地址可能是不同的。再看下共享内存在进程虚拟地址空间布局中的位置：
看共享内存相关函数：
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg); /* 创建 或 获取 共享内存 */
int shmctl(int shmid, int cmd, struct shmid_ds *buf); /* 配置共享内存 */
void *shmat(int shmid, const void *shmaddr, int shmflg); /* 建立到共享内存的映射 */
int shmdt(const void *shmaddr); /* 移除到共享内存的映射 */看一个例子，仍然是一个写程序和一个读程序。两个程序的共同头文件 shm_common.h ：
#ifndef SHM_COMMON_H
#define SHM_COMMON_H
#define MY_SHM_KEY 1234
#define TEXT_SZ 2048
#define MSG_END "<END>"
struct shared_data {
int data_avail;
char text[TEXT_SZ];
};
#endif /* SHM_COMMON_H */写程序 shm_write.c ：
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "shm_common.h"
int main (void)
{
int running = 1;
int shmid;
void *shared_vaddr = NULL;
struct shared_data *shared;
char buffer[BUFSIZ];
static const char *msg_text[] = {
"message 001",
"message 002",
"message 003",
MSG_END
};
int i;
shmid = shmget((key_t)MY_SHM_KEY, sizeof(struct shared_data), 0666 | IPC_CREAT);
if (shmid == -1) {
perror("shmget");
exit(EXIT_FAILURE);
}
shared_vaddr = shmat(shmid, NULL, 0);
if (shared_vaddr == (void *)-1) {
perror("shmat");
exit(EXIT_FAILURE);
}
printf("Memory attached at %p\n", shared_vaddr);
shared = (struct shared_data *)shared_vaddr;
for (i = 0; i < sizeof(msg_text)/sizeof(msg_text[0]); i++) {
while (shared->data_avail)
asm("nop");
strcpy(shared->text, msg_text[i]);
shared->data_avail = 1;
}
if (shmdt(shared_vaddr) == -1) {
perror("shmdt");
exit(EXIT_FAILURE);
}
return 0;
}
读程序 shm_read.c ：
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <error.h>
#include "shm_common.h"
int main (void)
{
int shmid;
void *shared_vaddr = NULL;
struct shared_data *shared;
shmid = shmget((key_t)MY_SHM_KEY, sizeof(struct shared_data), 0666 | IPC_CREAT);
if (shmid == -1) {
perror("shmget");
exit(EXIT_FAILURE);
}
shared_vaddr = shmat(shmid, NULL, 0);
if (shared_vaddr == (void *)-1) {
perror("shmat");
exit(EXIT_FAILURE);
}
printf("Memory attached at %p\n", shared_vaddr);
shared = (struct shared_data *)shared_vaddr;
shared->data_avail = 0;
for (;;) {
if (shared->data_avail) {
printf("%s\n", shared->text);
if (strcmp(shared->text, MSG_END) == 0)
break;
shared->data_avail = 0;
}
}
if (shmdt(shared_vaddr) == -1) {
perror("shmdt");
exit(EXIT_FAILURE);
}
return 0;
}
编译和运行：
$ make shm_read shm_write
$ ./shm_read
$ ./shm_write同样，共享内存也可用于父子进程间的通信，感兴趣的读者可以自行实践。
2.4 信号量
先看信号量函数集：
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg); /* 创建 或 获取 一个已有信号量 */
int semctl(int semid, int semnum, int cmd, ...); /* 配置信号量 */
int semop(int semid, struct sembuf *sops, size_t nsops); /* 改变信号量的值 */
int semtimedop(int semid, struct sembuf *sops, size_t nsops,
const struct timespec *timeout);看一个例子，代码来自此处：
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/sem.h>
#include <errno.h>
union semun {
int val;
struct semid_ds *buf;
unsigned short *arry;
};
static int init_semaphore(int sem_id);
static int fini_semaphore(int sem_id);
static int semaphore_p(int sem_id);
static int semaphore_v(int sem_id);
int main(int argc, char *argv[])
{
char message = 'X';
int sem_id, i = 0;
sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);
if (sem_id == -1) {
perror("semget");
exit(EXIT_FAILURE);
}
if (argc > 1) { /* first time to init */
if (!init_semaphore(sem_id))
exit(EXIT_FAILURE);
message = argv[1][0];
sleep(2);
}
for (i = 0; i < 10; ++i) {
if (!semaphore_p(sem_id))
exit(EXIT_FAILURE);
printf("%c", message);
fflush(stdout);
sleep(rand() % 3);
printf("%c\n", message);
fflush(stdout);
if (!semaphore_v(sem_id))
exit(EXIT_FAILURE);
sleep(rand() % 2);
}
sleep(10);
printf("\n%d - finished\n", getpid());
if (argc > 1) {
sleep(3);
fini_semaphore(sem_id);
}
exit(EXIT_SUCCESS);
}
static int init_semaphore(int sem_id)
{
union semun sem_union;
sem_union.val = 1;
if (semctl(sem_id, 0, SETVAL, sem_union) == -1) {
perror("semctl");
return 0;
}
return 1;
}
static int fini_semaphore(int sem_id)
{
union semun sem_union;
if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1) {
perror("semctl");
return 0;
}
return 1;
}
static int semaphore_p(int sem_id)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1;
sem_b.sem_flg = SEM_UNDO;
if (semop(sem_id, &sem_b, 1) == -1) {
perror("semop");
return 0;
}
return 1;
}
static int semaphore_v(int sem_id)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = 1;
sem_b.sem_flg = SEM_UNDO;
if (semop(sem_id, &sem_b, 1) == -1) {
perror("semop");
return 0;
}
return 1;
}编译和运行：
$ make sem_test
$ ./sem_test 0
$ ./sem_test2.5 网络套接字
就上张图吧，其它的就不多说了。
图片来自于 这里 。
2.6 UNIX套接字
有点类似于命名管道(FIFO)，也许我们可以把UNIX套接字说成命名socket。更多细节参考博客 https://blog.csdn.net/inthat/article/details/27371939 。
2.7 信号
#include <signal.h>
int kill(pid_t pid, int sig); /* 发送信号到进程 */
int killpg(int pgrp, int sig); /* 发送信号到进程组 */
int tgkill(pid_t tgid, pid_t tid, int sig); /* 发送信号到线程 */
int syscall(SYS_pidfd_send_signal, int pidfd, int sig, siginfo_t *info,
unsigned int flags); /* 发送信号到进程 */3. 参考资料
《Advanced Programming in the UNIX Envinronment》
https://zhuanlan.zhihu.com/p/556004836
https://blog.csdn.net/fukangwei_lite/article/details/120640540
https://blog.csdn.net/m0_52387305/article/details/124149859
https://blog.csdn.net/inthat/article/details/27371939
1567
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
