【嵌入式开发之并发程序设计】进程间通信：无名管道和有名管道

一个嵌入式新手的成长

于 2024-07-29 23:51:24 发布

阅读量899

点赞数 17

分类专栏：嵌入式进阶笔记之并发程序设计文章标签： linux 运维 c语言

本文链接：https://blog.csdn.net/boy_ding_jian/article/details/140757120

版权

嵌入式进阶笔记之并发程序设计专栏收录该内容

4 篇文章 0 订阅

订阅专栏

进程间通信

进程间通信（IPC，InterProcess Communication），就是进程和进程之间交换信息。

无名管道（pipe）
有名管道（fifo）
信号（signal）共享内存(mmap)
套接字（socket）
System V IPC
共享内存（share memory）
消息队列（message queue）
信号灯集（semaphore set）

无名管道

无名管道的特点

只能用于具有亲缘关系的进程之间的通信
单工的通信模式，具有固定的读端和写端
无名管道创建时会返回两个文件描述符，分别用于读写管道

无名管道的创建

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

成功时返回0，失败时返回EOF
pfd：包含两个元素的整形数组，用来保存文件描述符
pfd[0]用于读管道；pfd[1]用于写管道

无名管道注意事项

只能用于亲缘关系的进程间通信（父子进程，兄弟进程）
管道通信是单工的，一端读，一端写（程序实现设计好）。
数据自己读不能自己写
管道可以用于大于2个进程共享，比如1个父进程fork出两个子进程，两个子进程分别写入内容，父进程读取内容

实例代码

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main(int argc, const char *argv[])
{
	int pfd[2];
	int re;
	int i;
	char buf[40] = {0};
	pid_t pid;
	re = pipe(pfd);

	if ((re = pipe(pfd)) < 0) {
		perror("pipe");
		return 0;
	}
	printf("%d %d\n", pfd[0], pfd[1]);

	for (i = 0; i < 2; i++) {
		pid = fork();

		if (pid < 0) {
			perror("fork");
			return 0;
		} else if (pid > 0){
			
		} else {
			break;
		}
	}

	if (i == 2) {//父进程
		close(pfd[1]);
		while (1) {
			memset(buf, 0, 20);
			re = read(pfd[0], buf, 40);
			if (re > 0) {
				printf("%s\n", buf);
			}
		}
		return 0;
	}

	if (i == 1) {//第二次fork出来的子进程
		close(pfd[0]);
		while(1) {
			strcpy(buf, "this is 2 process");
			write(pfd[1], buf, strlen(buf));
			usleep(930000);
		}
		return 0;
	}

	if (i == 0) {//第一次fork出来的子进程
		close(pfd[0]);
		while(1) {
			strcpy(buf, "this is 1 process");
			write(pfd[1], buf, strlen(buf));
			sleep(1);
		}
		return 0;
	}
	
	return 0;
}

运行结果及分析

$ gcc -o pipe2_t pipe2_t.c 
$ ./pipe2_t
5 6
this is 1 process
this is 2 process
this is 2 process
this is 1 process
this is 2 process
this is 1 process
this is 2 process
this is 1 process
this is 2 process
this is 1 process
this is 2 process

子进程全部关闭读管道，父进程关闭写管道，子进程可以同时写入，父进程读出。

无名管道的读写特性

读管道

管道中有数据，read返回实际读到的字节数。
管道中无数据：
- 管道写端被全部关闭，read返回0 (好像读到文件结尾)
- 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)

实例代码（写段全部关闭，read返回0）

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main(int argc, const char *argv[])
{
	int pfd[2];//pfd[0]为读描述符，pfd[1]为写描述符
	int re;
	char buf[20];
	pid_t pid;
	re = pipe(pfd);

	if ((re = pipe(pfd)) < 0) {
		perror("pipe");
		return 0;
	}
	printf("%d %d\n", pfd[0], pfd[1]);

	pid = fork();

	if (pid < 0) {
		perror("fork");
		return 0;
	} else if (pid > 0){
		close(pfd[0]);//关闭读
		close(pfd[1]);//关闭写
		while(1) {
			strcpy(buf, "hhahahahah");
			write(pfd[1], buf, strlen(buf));
			sleep(1);
		}
	} else {
		close(pfd[1]);//关闭写
		while(1) {
			re = read(pfd[0], buf, 20);
			if (re > 0) {
				printf("read pipe = %s\n", buf);
			} else if (re == 0) {
				printf("re = 0\n");
			}
		}
	}
	
	return 0;
}

运行结果及分析

re = 0
re = 0
re = 0
re = 0
re = 0
re = 0
re = 0
re = 0
re = 0
re = 0
re = 0
re = 0
re = 0

实现代码（写端不关闭，但也不写，阻塞）

把上面代码中以下两句注释掉：

//close(pfd[1]);//关闭写
//write(pfd[1], buf, strlen(buf));

运行结果及分析

$ gcc -o pipe3_t pipe3_t.c 
$ ./pipe3_t
5 6

read阻塞等待。

写管道

管道读端全部被关闭，进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)
管道读端没有全部关闭：
- 管道已满，write阻塞。（管道大小64K）
- 管道未满，write将数据写入，并返回实际写入的字节数。

实例代码（读端全部关闭）

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, const char *argv[])
{
	int pfd[2];//pfd[0]为读描述符，pfd[1]为写描述符
	int re;
	char buf[20];
	pid_t pid;
	re = pipe(pfd);

	if ((re = pipe(pfd)) < 0) {
		perror("pipe");
		return 0;
	}
	printf("%d %d\n", pfd[0], pfd[1]);

	pid = fork();

	if (pid < 0) {
		perror("fork");
		return 0;
	} else if (pid > 0){
		close(pfd[0]);//关闭读
		//close(pfd[1]);//关闭写
		while(1) {
			strcpy(buf, "hhahahahah");
			write(pfd[1], buf, strlen(buf));
			sleep(1);
		}
	} else {
		close(pfd[1]);//关闭写
		close(pfd[0]);//关闭读
		sleep(3);
		exit(0);
		while(0) {
			re = read(pfd[0], buf, 20);
			if (re > 0) {
				printf("read pipe = %s\n", buf);
			} else if (re == 0) {
				printf("re = 0\n");
			}
		}
	}
	
	return 0;
}

运行结果及分析

$ gcc -o pipe3_t pipe3_t.c
$ ./pipe3_t
5 6

管道读端全部被关闭，进程异常终止

实例代码（管道已满，write阻塞）

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, const char *argv[])
{
	int pfd[2];//pfd[0]为读描述符，pfd[1]为写描述符
	int re;
	char buf[20];
	pid_t pid;
	re = pipe(pfd);

	if ((re = pipe(pfd)) < 0) {
		perror("pipe");
		return 0;
	}
	printf("%d %d\n", pfd[0], pfd[1]);

	pid = fork();

	if (pid < 0) {
		perror("fork");
		return 0;
	} else if (pid > 0){
		close(pfd[0]);//关闭读
		//close(pfd[1]);//关闭写
		int j = 0;
		while(1) {
			j++;
			strcpy(buf, "hhahahahah");
			for (int i = 0; i < 1000; i++) {
				write(pfd[1], buf, strlen(buf));
			}
			printf("write %d times\n", j);
			sleep(1);
		}
	} else {
		close(pfd[1]);//关闭写
		//close(pfd[0]);//关闭读
		sleep(30000);
		exit(0);
		while(1) {
			re = read(pfd[0], buf, 20);
			if (re > 0) {
				printf("read pipe = %s\n", buf);
			} else if (re == 0) {
				printf("re = 0\n");
			}
		}
	}
	
	return 0;
}

运行结果及分析

$ gcc -o pipe3_t pipe3_t.c 
$ ./pipe3_t
5 6
write 1 times
write 2 times
write 3 times
write 4 times
write 5 times
write 6 times

写入6次后发生阻塞，实际上，管道大小为64K。

有名管道

有名管道的特点

有名管道可以使非亲缘的两个进程互相通信
通过路径名来操作，在文件系统中可见，但内容存放在内存中
文件IO来操作有名管道
遵循先进先出规则
不支持leek操作
单工读写

有名管道的创建

#include  <unistd.h>
#include <fcntl.h>
int  mkfifo(const char *path, mode_t mode);

成功时返回0，失败时返回EOF
path：创建的管道文件路径
mode：管道文件的权限，如0666

有名管道的读写

有名管道写入实例fifow.c

循环从键盘输入并写入有名管道myfifo

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

int main(int argc, const char *argv[])
{
	int re;
	int fd;
	char buf[32];

	re = mkfifo("/myfifo", 666);
	if (re < 0) {
		perror("mkfifo");
		//return 0;
	}

	fd = open("/myfifo", O_WRONLY);
	if (fd < 0) {
		perror("open");
		return 0;
	}

	while(1) {
		fgets(buf, 32, stdin);
		write(fd, buf, strlen(buf));
	}

	close(fd);

	return 0;
}

管道文件打开的几种方式

open(const char *path, O_RDONLY);//1
open(const char *path, O_RDONLY | O_NONBLOCK);//2
open(const char *path, O_WRONLY);//3
open(const char *path, O_WRONLY | O_NONBLOCK);//4

有名管道读取实例fifor.c

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

int main(int argc, const char *argv[])
{
	int re;
	int fd;
	char buf[32];

	/*
	re = mkfifo("/myfifo", 666);
	if (re < 0) {
		perror("mkfifo");
		return 0;
	}
	*/

	fd = open("/myfifo", O_RDONLY);
	if (fd < 0) {
		perror("open");
		return 0;
	}

	while(1) {
		re = read(fd, buf, 32);
		if (re > 0) {
			printf("read fifor = %s\n", buf);
		} else if (re == 0) {
			exit(0);
		}
	}

	close(fd);

	return 0;
}

运行结果及分析

运行文件fifow.c，在/目录下会生成管道文件myfifo

一个窗口运行fifow.c生成的可执行文件fifow，另一个窗口运行fifor.c生成的可执行文件fifor，如果在运行fifow文件的窗口输入，在运行fifor文件的窗口会输出同样的内容，证明管道已经建好。

注意事项

就是程序不能以O_RDWR(读写)模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程可以读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递。
第二个参数中的选项O_NONBLOCK，选项O_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的。
对于以只读方式（O_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。
对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。
数据完整性,如果有多个进程写同一个管道，使用O_WRONLY方式打开管道，如果写入的数据长度小于等于PIPE_BUF（4K），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。