进程间通信 —— 早期通信

已于 2023-11-05 20:13:31 修改
阅读量146 收藏 1
点赞数 1
分类专栏： # IO 与 进程 文章标签： c语言 linux
于 2023-11-05 20:10:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41566483/article/details/134233537
版权

发展

1、早期通信方式
2、AT&T 的贝尔实验室，对 Unix 早期的进程间通信进行了改进和扩充，形成了“system V IPC”
（InterProcess Communication），其通信进程主要局限在单个计算机内。
3、BSD（加州大学伯克利分校的伯克利软件发布中心），跳过了只能在同一计算机通信的限制，
形成了基于套接字（socket）的进程间通信机制。

进程间通信方式

1、早期通信：

无名管道（pipe），有名管道（fifo），信号（sem）
将数据写入管道、从管道中读出数据。

2、system V IPC：

共享内存（share memory），信号灯集（semaphore），消息队列（message queue）
共享内存：被两个或多个进程共享，通信效率最高。
信号灯集：控制同步与互斥。
消息队列：根据类型不同，匹配不同的接收/发送方。

3、BSD：

套接字（socket）

进程间的早期通信

无名管道（pipe）

在这里插入图片描述
在这里插入图片描述

无名管道的特点

1、只能用于具有亲缘关系的进程之间通信；
2、半双工通信，具有固定的读端和写端；
单工： 只能单方面传输信息，（广播、电视……）
半双工： 可以双向传输信息，但同一时刻只能一个方向传输信息，（对讲机……）
全双工： 可以双向、同时传输信息，（电话……）
3、可以看作特殊的文件（但不是文件），对于无名管道的读写可以使用 文件IO函数 read、write；
4、基于文件描述符进行通信，
当一个无名管道建立，它会创建两个文件描述符，一个是固定的读端，一个是固定的写端。

函数

int pipe(int fd[2]); 
功能：创建无名管道
参数：文件描述符 	fd[0]：读端  	fd[1]：写端
返回值：成功 0
       失败 -1

在这里插入图片描述
在这里插入图片描述

注意事项

1、当管道中无数据时，读会阻塞

在这里插入图片描述

2、当管道中写满（64k）数据时，写阻塞；一旦有4k空间，写继续，直到写满为止

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3、将写端关闭，读操作立即返回（管道中无数据时）

在这里插入图片描述

4、将读端关闭，继续写数据，会导致管道破裂

进程会收到内核发送过来的SIGPIPE信号（Broken pipe）。
在这里插入图片描述
在这里插入图片描述

练习：利用无名管道实现进程通信

// 父子进程实现通信，父进程循环从终端输入数据，子进程循环打印数据，当输入 quit 结束。

#include <stdio.h>
#include <unistd.h> 
#include <string.h>     
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char const *argv[])
{
    char buf[64] = {};

    int fd[2];
    if (pipe(fd)){
        perror("Failed: ");
        return -1;
    }

    pid_t pid = fork();
    if (pid < 0){

        perror("Failed: ");
        return -1;

    } else if (pid > 0){
        
        while (1){
            scanf("%s", buf);
            write(fd[1], buf, 64);          // 这里也不能用 strlen(buf)
            if (!strcmp(buf, "quit"))
                break;
        }
        wait(NULL);							// 阻塞等待子进程结束，回收子进程

    } else {
        while (1){
            read(fd[0], buf, 64);           // 此 buf 非彼 buf, 不能用 strlen(buf)
            if (!strcmp(buf, "quit"))
                break;
            printf("%s\n", buf);
        }
    }

    close(fd[0]);
    close(fd[1]);
    return 0;
}

在这里插入图片描述
在这里插入图片描述

运行结果如下：
在这里插入图片描述

有名管道（fifo）

有名管道的特点

1、有名管道可以使互不相关的两个进程互相通信；
2、有名管道可以 通过路径名来指出，并且在文件系统中可见，但内容存放在内存中；
3、通过 文件IO 来操作有名管道，半双工通信；
4、有名管道遵循 先进先出规则；
5、不支持 lseek() 操作。

函数

int mkfifo(const char *filename,mode_t mode);
功能：创健有名管道
参数：filename：有名管道文件名
      mode：权限
返回值：成功：0
       失败：-1，并设置errno号

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

注意对错误的处理方式：
如果错误是file exist时，注意加判断，如：if(errno == EEXIST) 或 if(errno == 17)

注意事项：

1、只写方式，写阻塞（open处），直到另一个进程将读打开

在这里插入图片描述
在这里插入图片描述

2、只读方式，读阻塞（open处），直到另一个进程将写打开

在这里插入图片描述
在这里插入图片描述

3、可读可写，若管道中无数据，读阻塞

在这里插入图片描述

练习：通过两个进程实现 cp功能

// Write_into_fifo.c

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

int main(int argc, char const *argv[])
{
    if (mkfifo("./fifo", 0666)){
        if (errno == EEXIST)                	// 或 errno == 17
            printf("File exists!\n");
        else {
            perror("Failed ");
            return -1;
        }
    }

    int fd_f = open("./fifo", O_WRONLY);		// 不要写 O_RDONLY ！！！
    int fd_txt = open(argv[1], O_RDONLY);
    if (fd_f < 0 || fd_txt < 0){
        perror("Failed ");
        return -1;
    }

    char buf[64] = {};
    while (1){
        int num = read(fd_txt, buf, 64);		// 从 A文件 读入 数组
        if (num <= 0)
            break;
        write(fd_f, buf, num);					// 从 数组 写入 有名管道
    }
    
    close(fd_f);
    close(fd_txt);

    return 0;
}

// Read_from_fifo.c

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

int main(int argc, char const *argv[])
{
    if (mkfifo("./fifo", 0666)){
        if (errno == EEXIST)                	// 或 errno == 17
            printf("File exists!\n");
        else {
            perror("Failed ");
            return -1;
        }
    }

    int fd_f = open("./fifo", O_RDONLY);		// 不要写 O_WRONLY ！！！
    int fd_txt = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd_f < 0 || fd_txt < 0){
        perror("Failed ");
        return -1;
    }

    char buf[64] = {};
    while (1){
        int num = read(fd_f, buf, 64);			// 从 有名管道 读入数组
        if (num <= 0)
            break;
        write(fd_txt, buf, num);				// 从 数组 写入 B文件
    }

    close(fd_f);
    close(fd_txt);

    return 0;
}

在这里插入图片描述

input.c --> 读源文件，写到管道里
1）创建管道
2）打开源文件，管道文件
3）循环读源文件，写管道
4）关闭文件描述符
output.c --> 读管道，写到目标文件里面
1）创建管道
2）打开目标文件，管道文件
3）循环读管道文件，写目标文件
4）关闭文件描述符
在这里插入图片描述
在这里插入图片描述

练习：两进程间实现全双工

在这里插入图片描述

有名管道 & 无名管道

在这里插入图片描述

信号

概念

1）信号是在软件层次上对中断机制的一种模拟，是异步通信方式；
2）信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件；
3）如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行再传递给它；如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。

信号的响应方式

1、忽略信号：对信号不做任何处理，但是有两个信号不能忽略：即 SIGKILL 及 SIGSTOP。
2、捕捉信号：定义信号处理函数，当信号发生时，执行相应的处理函数。pause() 结束的条件。
3、执行缺省操作：Linux 对每种信号都规定了默认操作 。

信号种类

在这里插入图片描述

函数接口

kill
int kill(pid_t pid, int sig);
功能：信号发送
参数：pid：指定进程
   sig：要发送的信号
返回值：成功 0     
       失败 -1

在这里插入图片描述

raise
int raise(int sig);
功能：进程向自己发送信号
参数：sig：信号
返回值：成功 0   
       失败 -1

在这里插入图片描述

pause
int pause(void);
功能：用于将调用进程挂起，直到捕捉到信号为止。

在这里插入图片描述

alarm
unsigned int alarm(unsigned int seconds); 
功能：在进程中设置一个定时器
参数：seconds：定时时间，单位为秒
返回值：如果调用此alarm()前，进程中已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。
注意：一个进程只能有一个闹钟时间。如果在调用alarm时已设置过闹钟时间，则之前的闹钟时间被新值所代替

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    int a = alarm(5);       		// 这里不是最后一个 alarm, 不等待
    printf("%d\n", a);      		// a == 0, 第一次调用 alarm 返回值为 0 

    printf("Hola~ \n");

    sleep(2);                       // 等待 2s

    printf("%d\n", alarm(20));      // 再次调用 alarm 将返回上次所剩时间 == 5-2 == 3
                                	// 最后一个 alarm, 等待
    pause();

    return 0;
}

运行结果如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

signal
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
功能：信号处理函数
参数：signum：要处理的信号
      handler：信号处理方式
        	SIG_IGN：忽略信号
            SIG_DFL：执行默认操作
            handler：捕捉信号  				void handler(int sig){} //函数名可以自定义
返回值：成功：设置之前的信号处理方式
       失败：-1
1、忽略信号

signal(信号, SIG_IGN);

有两个信号不能忽略：即 SIGKILL 及 SIGSTOP。
在这里插入图片描述

2、缺省操作

signal(信号, SIG_DFL);
在这里插入图片描述

3、捕捉操作

void handler(int sig){
/* blablabla… */
}

void main(){
signal(信号, handler);
}

在这里插入图片描述

练习：司机和售票员问题

1）售票员捕捉 SIGINT（代表开车）信号，向司机发送 SIGUSR1 信号，司机打印（Let’s go）
2）售票员捕捉 SIGQUIT（代表停车）信号，向司机发送 SIGUSR2 信号，司机打印（Stop the bus）
3）司机捕捉 SIGTSTP（代表到达终点站）信号，向售票员发送 SIGUSR1 信号，
售票员打印（Please get off the bus）
4）司机等待售票员下车，之后司机再下车。
分析：由 4）可知，利用父子进程完成此练习 —> 售票员子进程，司机父进程
司机：
忽略：SIGINT、SIGQUIT
捕捉：SIGUSR1 —> （Let’s go）
SIGUSR2 —> （Stop the bus）
SIGTSTP —> 向售货员发送 SIGUSR1 —> 等待回收子进程
售票员：
忽略：SIGTSTP
捕捉：SIGINT —> 向司机发送 SIGUSR1
SIGQUIT —> 向司机发送 SIGUSR2
SIGUSR1 —> （Please get off the bus）—> 结束子进程

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <sys/types.h>
#include <stdlib.h>

pid_t pid, pid_f, pid_c;

void handler(int sig){
    switch (sig)
    {
    case SIGINT:
        kill(getppid(), SIGUSR1);
        break;
    case SIGQUIT:
        kill(getppid(), SIGUSR2);		// 子进程获取父进程的ID，向父进程传送信号
        break;
    case SIGUSR1:
        if (getpid() == pid_f){
            printf("\nLet's go!\n");
        } 
        if (getpid() == pid_c){
            printf("\nPlease get off the bus!\n");
            exit(0);
        }
        break;
    case SIGUSR2:
        printf("\nStop the bus!\n");
        break;
    case SIGTSTP:
        kill(pid, SIGUSR1);			// 父进程获取子进程的ID，向子进程传送信号
        break;
    default:
        break;
    }
}

int main(int argc, char const *argv[])
{
    pid = fork();					// 父进程内返回子进程的ID，子进程内返回0
    if (pid < 0){
        perror("Failed ");
        return -1;

    } else if (pid == 0){
        
        pid_c = getpid();
        signal(SIGTSTP, SIG_IGN);
        signal(SIGINT, handler);
        signal(SIGQUIT, handler);
        signal(SIGUSR1, handler);

        while(1)					// 保证可以循环输入信号，不能写在 return 0 前面，
            pause();				// 否则执行不到就退出程序

    } else {
        pid_f = getpid();
        signal(SIGINT, SIG_IGN);
        signal(SIGQUIT, SIG_IGN);
        signal(SIGUSR1, handler);       
        signal(SIGUSR2, handler);
        signal(SIGTSTP, handler);
	
        wait(NULL);					// 等待回收子进程
        exit(0);					// 这里要退出父进程，后面的语句不再执行
    }
    return 0;
}

也可以将捕捉函数拆分成两个：
在这里插入图片描述

运行结果如下：
在这里插入图片描述

_小白__
关注
专栏目录
（面经总结）一篇文章带你深挖进程之间的通信
南淮北安的博客
03-22 291
文章目录一、为什么要进行进程之间的通信二、管道1. 总结2. 详细内容二、消息队列三、共享内存四、信号量五、socket 一、为什么要进行进程之间的通信 因为有时候想要在两个进程之间实现数据传输、资源共享、通知事件（例如进程终止时会通知父进程）以及进程控制（debug进程可以控制其他进程的执行）， 但是我们知道进程组织的时候是一个结构体，进程与进程之间是相互独立的，有独立的虚拟地址空间，所以进程间通信是很难的， 但内核空间是每个进程都共享的，所以进程之间要通信必须通过内核。 进程通信的具体方式有：管道，消
Win32应用程序中进程间通信方法分析与比较(转)
设计模式空间
01-11 2702
Win32应用程序中进程间通信方法分析与比较作者:李志刚 纪玉波 程小茁 崔朝辉,引用本文供学习使用摘 要 随着人们对应用程序的要求越来越高，单进程应用在许多场合已不能满足人们的要求。编写多进程/多线程程序成为现代程序设计的一个重要特点，在多进程程序设计中，进程间的通信是不可避免的。Microsoft Win32 API提供了多种进程间通信的方法，全面地阐述了这些方法的特点，并加以比较和分析，希望
进程间通信
li2713575075的博客
04-02 151
如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。否则，会导致管道破裂，向管道中写入数据的进程将收到内核传来的SIGPIPE信号 (通常Broken pipe错误)。2）信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件。SIGALRM：闹钟信号，alarm函数设置定时，当到设定的时间时，内核会向进程发送此信号结束进程。消息队列就是一个消息的列表。1）共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，
进程之间的通信
qq_40409143的博客
01-10 190
之前面试的时候被面试官问道，进程之间是怎么进行通信的？ 1.线程和进程之间的区别 可以把进程比作一辆火车。进程是火车上的车厢。所以一个进程有多个线程。 2.进程之间是怎么进行通信的 7种方式： ...
进程管理之进程间通信
青萍之末的博客
03-13 748
文章目录一、管道（pipe）二、命名管道（FIFO）三、信号量（Semaphore）1、信号量的基本要素2、信号量的原理3、使用信号量实现生产者-消费者问题 4、使用信号量实现读者-写者问题四、消息队列（message queue）五、共享内存（shared memory）六、套接字（socket）   进程作为人类的发明，自然也免不了脱离人类的习性，也有通信的需求。如果进程之间不进行任何通信，那...
Linux进程间通信——使用流套接字
01-20
前面说到的进程间的通信，所通信的进程都是在同一台计算机上的，而使用socket进行通信的进程可以是同一台计算机的进程，也是可以是通过网络连接起来的不同计算机上的进程。通常我们使用socket进行网络编程，这里将会...
详解Linux进程间通信——使用信号量
09-15
### 详解Linux进程间通信——使用信号量 #### 一、什么是信号量 信号量是一种常用的同步机制，用于解决多进程或线程并发访问共享资源时可能出现的竞争条件问题。在多进程环境中，当多个进程尝试同时访问同一个共享...
「操作系统」进程间的通信方式全面解析
frozenpenguin的博客
03-16 3545
匿名管道顾名思义，它没有名字标识，匿名管道是特殊文件只存在于内存，没有存在于文件系统中，shell 命令中的「」竖线就是匿名管道，通信的数据是无格式的流并且大小受限，通信的方式是单向的，数据只能在一个方向上流动，如果要双向通信，需要创建两个管道，再来匿名管道是只能用于存在父子关系的进程间通信，匿名管道的生命周期随着进程创建而建立，随着进程终止而消失。命名管道。
网络通信- 父子进程的通信（本地通信）
永远积极向上、永远热泪盈眶、永远豪情满怀、永远坦坦荡荡
11-04 961
本地套接字使用 struct sockaddr_un ; bind的时候仍然需要强转 创建套接字需要使用 AF_UNIX ，AF_UNIX, AF_LOCAL创建套接字的type可以选择TCP，也可以选择UDP，但是如果选择TCP，那么必须按照TCP的流程进行通信，如果选择UDP，必须按照UDP的流程进行通信。一， client#include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;std
C# 使用管道Pipe在进程间通信
03-25
进程间通信的一种方式，Pipes：管道，分为无名管道：在父子进程间交换数据；有名管道：可在不同主机间交换数据，分为服务器方和客户方，在Win9X下只支持有名管道客户。 1、进程间通信 2、管道Pipe通信
Linux C语言学习 day5： 进程间的通信方式
haogewudi666的博客
06-17 405
【1】复习 线程：基本概念和特点： 创建线程：pthread_create 线程退出：pthread_exit 线程阻塞：pthread_join gcc xx.c -lpthread 同步：多个线程按照约定的顺序 信号量 初始化：sem_init p操作：申请资源sem_wait v操作: 释放资源sem_post 互斥：多个线程执行时只能有一个线程来访问临界资源 互斥锁 初始化：pthread...
Linux中父子进程、兄弟子进程之间通信方式--匿名管道pipe(适用于有血缘关系的进程)
04-01 8059
文章目录编程环境：进程间通信 IPC：匿名管道（pipe）：父子进程间通信：兄弟子进程间通信：管道的读写行为：读操作：写操作：查看管道缓冲区大小：设置管道的非阻塞属性：下载地址： 简 述：　对于有血缘关系的进程间通信，如父子进程、兄弟子进程子之间的通信，可以采用（匿名）管道的 pipe 方式。 而进程间通信一共有四种方式：管道、信号、共享映射区、套接字。且说一个概念，进程间通信（Inter P...
父子进程的通信（非线程模拟 java）
centre10的专栏
10-28 2558
<br />说明：1.运行结果：farther receive:child receive:I am your fartherI am your son<br />         2.数据通过readline（）方法读出时已经去掉了"/n"符号，所以结果不会换行<br />         3.通过获得子进程的输入输出流，当父进程将数据写到管道后，必须在此管道关闭后，子进程才能操作。子进程发送数据也是一样的<br />         4.进程间通信是异步的，从运行结果也可以看出。<br />      
//要求实现父子进程对话//父进程先发送一句话给子进程，子进程接收后打印//子进程再回复一句话给父进程，父进程接收后打印//重复1.2步骤，当收到quit后，要结束父子进程
qq_53140444的博客
12-13 211
//要求实现父子进程对话 //父进程先发送一句话给子进程，子进程接收后打印 //子进程再回复一句话给父进程，父进程接收后打印 //重复1.2步骤，当收到quit后，要结束父子进程
实验4 Linux父子进程同步及进程通信
江南、寻你的博客
05-11 3445
【实验目的】 （1）熟悉在c语言源程序中使用linux所提供的系统调用界面的方法。 （2）理解同步的概念。 （3）使用系统调用wait()和exit()，实现父子进程同步。 （4）使用pipe()系统调用创建管道，实现父子进程间的信息通信。 【实验环境】VMware Workstation、RedHat 【实验步骤】 1.1 使用vi编写程序，通过wait()和exit()实现父子进程同步，其同步方式为父进程等待子进程的同步，即：子进程先循环输出5次，然后父进程再循环输出5次。 1.2 使用
无名管道-----实现父子进程相互通信
皮皮不调皮的博客
09-01 4325
创建一条无名管道并且给你两个文件描述符（读写的文件描述符） pipefd[0]:读端 pipefd[1]:写端 思路： 只需要一个.c即可，fork一次即可（因为用的是无名管道） 注意： 父进程： 发：scanf + write //你好我是旦丁 收：read + printf //卡住 子进程： 发：scanf《卡》 + write “我不是旦丁” 收：read《卡》 + printf #include <stdio.h> #include <errno.h> #inc
Linux之进程间通信（管道）
最新发布
zdlynj的博客
01-21 2714
什么是管道？1、管道是Unix中最古老的进程间通信的形式。2、我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。管道只能进行单向通信，用来传输资源：数据。我们按下面的步骤来分析：1、首先，父进程分别以读和写的方式，打开了一个文件。2、然后，父进程fork创建了一个子进程，我们知道，子进程会继承父进程，指向同一个文件。3、我们规定，父进程对文件写入，子进程对文件读取。关闭父子进程各自不需要的功能。即：父进程关闭读的文件描述符，子进程关闭写的文件描述符。
在一个父进程不断获得键盘的输入，发送到消息队列里，在子进程里不断读取消息队列的内容并送屏幕显示。可添加退出条件，当输入“quit”时退出。
Azure的博客
06-22 783
#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include <string.h> #define SIZE 1024 typedef struct _msg { int type; char data[SIZE]; .
嵌入式Linux：进程间通信详解
"《嵌入式Linux应用程序开发标准教程》第8章——进程间通信，讲解了Linux系统中进程通信的各种方法，包括管道、有名管道、消息队列、共享内存等，介绍了UNIX、SystemV和Posix的IPC机制，并重点讨论了在Linux环境下...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值