自学内容网 自学内容网
自学内容网 > 正文

Linux 基础入门操作 第九章 进程间通信之管道

🕗 发布于 2024-09-20 15:15 linux  

第九章 进程间通信

进程通信有如下一些目的：
A、数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几 M 字节之间
B、共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程，应该立刻看到。
C、通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
D、资源共享：多个进程之间共享同样的资源。为了作到这一点，需要内核提供锁和同步机制。
E、进程控制：有些进程希望完全控制另一个进程的执行（如 Debug 进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

现在 linux 使用的进程间通信方式：
1）管道（pipe）和有名管道（FIFO）
2）信号（signal）
3）消息队列
4）共享内存
5）信号量
6）套接字（socket)

9.1 管道

管道是 Linux 支持的最初 Unix IPC 形式之一，具有以下特点：
（1）管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；
（2）只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；
（3）单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的
文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
（4）数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添
加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

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

返回的 fd[0]用于读，fd[1]用于写。因此，一个进程在由 pipe()创建管道后，一般再 fork 一个子进程，然后通过管道实现父子进程间的通信（因此也不难推出，只要两个进程中存在亲缘关系，这里的亲缘关系指的是具有共同的祖先，都可以采用管道方式来进行通信）。

管道的局限：

  • 只支持单向数据流；
  • 只能用于具有亲缘关系的进程之间；
  • 没有名字；
  • 管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
  • 管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式。

9.1.1 单项管道

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
void read_from_pipe(int fd)
{
char message[100];
read(fd,message,100);
printf("The messiage from parent is %s\n",message);
}

void write_to_pipe(int fd)
{
char *message = "hello world\n";
write(fd,message,strlen(message)+1);
}
int main()
{
int fd[2];
pid_t pid;
int stat_val;
if(pipe(fd))
{
printf("error");
exit(1);
}
pid=fork();
switch(pid)
{
case -1:
printf("fork error");
exit(1);
case 0:
printf("The child process is:%d\n",getpid());
close(fd[1]);
read_from_pipe(fd[0]);
exit(0);
default:
printf("The father process is:%d\n",getpid());
close(fd[0]);
write_to_pipe(fd[1]);
wait(&stat_val);
exit(0);
}
return 0;
}

9.1.2 全双工通讯，两个通道

这里用pipe1 父进程发送子线程 ， ,pipe2 子线程发送父父线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
void child_rw_pipe(int readfd,int writefd)
{
char *message1="from child process\n";
write(writefd,message1,strlen(message1)+1);
char message2[100];
read(readfd,message2,100);
printf("child read is: %s\n",message2);
}
void parent_rw_pipe(int readfd,int writefd)
{
char *message1 = "from parent process\n";
write(writefd,message1,strlen(message1)+1);
char message2[100];
read(readfd,message2,100);
printf("parent read is: %s \n",message2);
}
int main()
{
int pipe1[2],pipe2[2];
pid_t pid;
int stat_val;
if(pipe(pipe1))
{
printf("error");
exit(1);
}
if(pipe(pipe2))
{
printf("error");
exit(1);
}
pid=fork();
switch(pid)
{
case -1:
printf("fork error");
exit(1);
case 0:
printf("The child process is:%d\n",getpid());
close(pipe1[1]);
close(pipe2[0]);
child_rw_pipe(pipe1[0],pipe2[1]);
exit(0);
default:
printf(“Thefather process is:%d\n",getpid());
close(pipe1[0]);
close(pipe2[1]);
parent_rw_pipe(pipe2[0],pipe1[1]);
wait(&stat_val);
exit(0);
}
return 0;
}

9.2 有名管道

FIFO 不同于管道之处在于它提供一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中。这样，即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信（能够访问该路径的进程以及 FIFO 的创建进程之间），因此，通过 FIFO 不相关的进程也能交换数据。

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

mkfifo()会依参数 pathname 建立特殊的 FIFO 文件，该文件必须不存在，而参数 mode 为该文件的权限（mode%~umask），因此 umask 值也会影响到 FIFO 文件的权限。Mkfifo()建立的 FIFO 文件其他进程都可以用读写一般文件的方式存取。当使用 open()来打开 FIFO 文件时，O_NONBLOCK 旗标会有影响
1、当使用 O_NONBLOCK 旗标时，打开 FIFO 文件来读取的操作会立刻返回，但是若还没有其他进
程打开 FIFO 文件来读取，则写入的操作会返回 ENXIO 错误代码。
2、没有使用 O_NONBLOCK 旗标时，打开 FIFO 来读取的操作会等到其他进程打开 FIFO 文件来写入才正常返回。同样地，打开 FIFO 文件来写入的操作会等到其他进程打开 FIFO 文件来读取后才正常返回。

下面用server 发送，client 接收实现全双工通讯。

server.c

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#define FIFO_READ "readfifo"
#define FIFO_WRITE "writefifo"
#define BUF_SIZE 1024
int main(void)
{
int wfd,rfd;
char buf[BUF_SIZE];
int len;
umask(0);
if(mkfifo(FIFO_WRITE,S_IFIFO|0666)){
printf("can't create FIFO %s beause %s",FIFO_WRITE,strerror(errno));
exit(1);
}
umask(0);
wfd = open(FIFO_WRITE,O_WRONLY);
if(wfd == -1){
printf("open FIFO %s error :%s",FIFO_WRITE,strerror(errno));
exit(1);
}
while((rfd = open(FIFO_READ,O_RDONLY)) == -1){
sleep(1);
}
while(1) {
printf("Server:");
fgets(buf,BUF_SIZE,stdin);
buf[strlen(buf)-1] = '\0';
if(strncmp(buf,"quit",4) == 0) {
close(wfd);
unlink(FIFO_WRITE);
close(rfd);
exit(0);
}
write(wfd,buf,strlen(buf));
len = read(rfd,buf,BUF_SIZE);
if(len > 0) {
buf[len] = '\0';
printf("Client:%s\n",buf);
}
}
}

linux中的 umask 函数主要用于：
在创建新文件或目录时,屏蔽掉新文件或目录不应有的访问允许权限。文件的访问允许权限共有9种，分别是：r w x r w x r w x（它们分别代表：用户读 用户写 用户执行 组读 组写 组执行 其它读 其它写 其它执行）。
其实这个函数的作用，就是设置允许当前进程创建文件或者目录最大可操作的权限，比如这里设置为0，它的意思就是0取反再创建文件时权限相与，也就是：(~0) & mode 等于八进制的值0666 & mode了，这样就是给后面的代码调用函数mkfifo给出最大的权限，避免了创建目录或文件的权限不确定性。

S_IFIFO|0666”指明创建一个命名管道且存取权限为0666，即创建者、与创建者同组的用户、其他用户对该命名管道的访问权限都是可读可写（这里要注意umask对生成的管道文件权限的影响）。

client.c

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#define FIFO_READ "writefifo"
#define FIFO_WRITE "readfifo"
#define BUF_SIZE 1024
int main(void)
{
int wfd,rfd;
char buf[BUF_SIZE];
int len;
umask(0);
if(mkfifo(FIFO_WRITE,S_IFIFO|0666)){
printf("can't create FIFO %s beause %s",FIFO_WRITE,strerror(errno));
exit(1);
}
while((rfd = open(FIFO_READ,O_RDONLY)) == -1) {
sleep(1);
}
Wfd = open(FIFO_WRITE,O_WRONLY);
if(wfd == -1){
printf("open FIFO %s error :%s",FIFO_WRITE,strerror(errno));
exit(1);
}
while(1){
len = read(rfd,buf,BUF_SIZE);
if(len > 0) {
buf[len] = '\0';
printf("Server:%s\n",buf);
}
printf("Client:");
fgets(buf,BUF_SIZE,stdin);
buf[strlen(buf)-1] = '\0';
if(strncmp(buf,"quit",4) == 0) {
close(wfd);
unlink(FIFO_WRITE);
close(rfd);
exit(0);
}
write(wfd,buf,strlen(buf));
}
return 0;
}

原文地址：https://blog.csdn.net/huanghongqi11/article/details/142357009

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024