day32 进程间通信

最新推荐文章于 2026-01-04 13:00:35 发布
原创 最新推荐文章于 2026-01-04 13:00:35 发布 · 356 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #运维 #服务器

Linux系统提供了多种进程之间的通信方式

例如：无名管道，有名管道，信号等

1、如果是同一进程下的多个线程，共享资源，所以线程之间的通信只需要注意互斥和同步即可。

2、如果是多个进程。由于进程之间不共享资源，所以进程间的通信需要用到，系统提供的内核空间。

无名管道

1、本质也是一个内核空间的文件，存储在内存中，读写数据都是一次性的。

2、无名管道写入数据后，一旦读出数据，数据就消失了。

3、无名管道，一旦打开，就出现读端和写端，如果进行读取数据，就要先关闭写端，如果想要写数据，就要先关闭读端。

4、无名管道工作原理是半双工，也就是同一时刻只能是A写B读，或者A读B写。

5、无名管道只能进行亲缘进程间的通信。

6、管道文件相关的函数属于文件IO部分，只能使用文件IO读写。

7、管道的读写端属于文件描述符，也遵循最小未分配原则。

单工：只能是A向B发信息，B不能向A发信息。

半双工：同一时刻只能A向B发信息，或者B向A发信息。

全双工：同一时刻AB都是收发信息。

无名管道API：

 #include <unistd.h>

       int pipe(int pipefd[2]);
       功能：创建一个无名管道.pipefd[0]读端 pipefd[1]：写端
       参数：文件描述符数组
       返回值：成功返回0，失败返回-1，并置位错误码。
       eg：
       int pipefd[2];
       if(pipe(pipefd)==-1)
       {
           perror("pipe");
           return -1;       
       }

练习：父进程写入管道，子进程读取管道数据

#include <myhead.h>

int main(int argc, const char *argv[])
{
    int pipefd[2];
    char buff[1024] = "hello world";
    char s[1024];
    if(pipe(pipefd)==-1)
    {
        perror("pipe");
        return -1;
    }//读端pipefd[0] 写端pipefd[1]
    pid_t pid = fork();//创建子进程
    if(pid==0)
    {
        close(pipefd[1]);//先关闭写端
        while(1)
        {
            sleep(1);
            read(pipefd[0],s,sizeof(s));
            printf("儿子在读取：%s\n",s);//输出读取的数据
        }
        close(pipefd[0]);//关闭读端
    }
    else if(pid>0)
    {
        close(pipefd[0]);//先关闭读端
        while(1)
        {
            sleep(1);
            write(pipefd[1],buff,sizeof(buff));
        }
        close(pipefd[1]);//完成后关闭写端
    }
    else
    {
        perror("fork");
        return -1;
    }
    
    return 0;
}

验证无名管道大小

#include <myhead.h>

int main(int argc, const char *argv[])
{
    int pipefd[2];
    char buff[1024] = "hello world";
    char s[1024];
    if(pipe(pipefd)==-1)
    {
        perror("pipe");
        return -1;
    }//读端pipefd[0] 写端pipefd[1]
    pid_t pid = fork();//创建子进程
    if(pid==0)
    {
        close(pipefd[1]);//先关闭写端
        while(1)
        {
            sleep(1);
            read(pipefd[0],s,sizeof(s));
            printf("儿子在读取：%s\n",s);//输出读取的数据
        }
        close(pipefd[0]);//关闭读端
    }
    else if(pid>0)
    {
        close(pipefd[0]);//先关闭读端
        while(1)
        {
            sleep(1);
            write(pipefd[1],buff,sizeof(buff));
        }
        close(pipefd[1]);//完成后关闭写端
    }
    else
    {
        perror("fork");
        return -1;
    }
    
    return 0;
}

1、当读端存在时，有多少就写多少，写够2^16K为止

2、当写端存在时，有多少就读多少，读完为止会在read处阻塞。

3、当读端不存在，写入管道，会导致管道破裂。

4、当写端不存在时，有多少就读多少，读完为止不会在read处阻塞。

有名管道

1、有名字的管道，相对于无名管道，可以进程非亲缘进程间的通信。

2、有名管道写入一次读取一次。

 #include <sys/types.h>
       #include <sys/stat.h>

       int mkfifo(const char *pathname, mode_t mode);
        功能：创建一个有名管道用于非亲缘进程间的通信
        参数1：有名管道名
        参数2：创建时的权限。
        返回值：成功返回0，失败返回-1，并置位错误码。

创建有名管道实现非亲缘进程间的通信

写端：
#include <myhead.h>

int main(int argc, const char *argv[])
{
    int k = mkfifo("./myfifo",0664);//创建有名管道
    if(k==-1)
    {
        perror("mkfifo");
        return -1;
    }
    
    int fd1 = open("./myfifo",O_WRONLY);//打开管道
    if(fd1==-1)
    {
        perror("open");
        return -1;
    }

    char buff[1024];
    while(1)//循环写入数据
    {
        printf("请输入内容：");
        int res = read(0,buff,sizeof(buff));//输入从0号描述符读取数据
        write(fd1,buff,res);//写入有名管道
    }
    close(fd1);//关闭有名管道
    return 0;
}

读端：
#include <myhead.h>

int main(int argc, const char *argv[])
{
    int fd2 = open("./myfifo",O_RDONLY);//打开管道文件
    if(fd2==-1)
    {
        perror("open");
        return -1;
    }
    char buff[1024];
    while(1)//循环读取数据
    {
        int res = read(fd2,buff,sizeof(buff));
        if(res==0)
        {
            printf("写入端退出\n");
            break;
        }
        write(1,buff,res);//写入标准输出描述符
    }
    close(fd2);//关闭管道文件    
    return 0;
}

练习：创建两个子父进程父进程写入管道1，子进程读取管道2，父进程写入管道2，子进程读取管道1，实现全双工通信。

#include <myhead.h>

int main(int argc, const char *argv[])
{
    int fd1 = open("./myfo1",O_WRONLY);
    int fd2 = open("./myfo2",O_RDONLY);
    if(fd1==-1||fd2==-1)
    {
        perror("open");
        return -1;
    }

    char buff[1024];

    pid_t pid = fork();
    if(pid>0)//父进程写入管道1
    {
        while(1)
        {
            printf("请输入内容：\n");
            int res = read(0,buff,sizeof(buff));
            write(fd1,buff,res);//写入管道1
        }
    }
    else if(pid==0)//子进程读取管道2
    {
        while(1)
        {
            int res = read(fd2,buff,sizeof(buff));
            write(1,buff,res);//读取内容显示出来
        }
    }
    else
    {
        perror("fork");
        return -1;
    }
    
    return 0;
}

信号发送函数signal

#include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);
       功能：信号处理函数，忽略，默认和捕获操作。
       参数1：信号号
       参数2：
       SIG_IGN：忽略信号，不执行任何的操作。
       SIG_DFL：默认信号，执行信号原始的操作。
       自定义函数：捕获，某个信号，捕获的信号处理方式由程序员决定。
       返回值：成功返回前一个信号号，失败返回SIG_ERR, 并置位错误码。

2、尝试 忽略，默认，捕获（2) SIGINT也就是ctrl+c

#include <myhead.h>

void hander(int tmy)
{
    if(tmy==SIGINT)
    {
        printf("捕获了ctrl+c\n");
    }
}
int main(int argc, const char *argv[])
{
#if 0
    if(signal(SIGINT,SIG_IGN)==SIG_ERR)//忽略ctrl +c信号
    {
        perror("signal");
        return -1;
    }
    if(signal(SIGINT,SIG_DFL)==SIG_ERR)//默认ctrl +c信号
    {
        perror("signal");
        return -1;
    }
#endif
    if(signal(SIGINT,hander)==SIG_ERR)//hander将会捕获SIGINT信号作为自己的参数
    {
        perror("signal");
        return -1;
    }
        
    int k = 0;
    while(1)
    {
        sleep(1);
        printf("唐明宇打呼噜k = %d\n",k);
        k++;
    }
    return 0;
}

 3、尝试 捕获（17) SIGCHLD

#include <myhead.h>
//SIGCHLD
void hander(int tmy)
{
    if(tmy==SIGCHLD)
    {
        printf("捕获到了SIGCHLD\n");
    }
}
int main(int argc, const char *argv[])
{
    pid_t pid;
    pid = fork();
    if(pid>0)
    {
        if(signal(SIGCHLD,hander)==SIG_ERR)//捕获SIGCHLD信号
        {
            perror("signal");
            return -1;
        }
    }
    else if(pid==0)
    {
        sleep(1);
        exit(0);//成功退出子进程
    }
    else
    {
        perror("fork");
        return -1;
    }
    wait(NULL);//阻塞回收子进程资源
    return 0;
}

 4、尝试捕获SIGSEGV信号

#include <myhead.h>
void fun(int tmy)
{
    sleep(1);
    if(SIGSEGV==tmy)
    {
        printf("内核发送了段错误信号\n");
    }
}
int main(int argc, const char *argv[])
{
    if(signal(SIGSEGV,fun)==SIG_ERR)//绑定信号
    {
        perror("signal");
        return -1;
    }

    int *p = NULL;
    *p = *p+1;
    while(1);
    return 0;
}

 4、捕获SIGTSTP信号 。

#include <myhead.h>

void hander(int tmy)
{
    if(tmy==SIGTSTP)
    {
        printf("捕获到了SIGTSTP\n");
    }
}
int main(int argc, const char *argv[])
{
        if(signal(SIGTSTP,hander)==SIG_ERR)//捕获SIGCHLD信号
        {
            perror("signal");
            return -1;
        }
    while(1)
    {
        printf("hello\n");
        sleep(1);
    }
    return 0;
}

 5、SIGALRM信号使用,模拟下棋alarm函数

#include <unistd.h>

       unsigned int alarm(unsigned int seconds);
       功能：设置定时时间，时间到了内核会向调用进程发送SIGALRM信号
       如果第二次设置了定时时间，那么alarm函数返回的是上一次剩余的秒数。
       参数：设置的秒数。
       返回值：成功返回上一次预定的剩余秒数，如果没有上一次预定的秒数返回0
#include <myhead.h>

void hander(int sss)
{
    if(sss==SIGALRM)
    {
        printf("收到内核发送的SIGALRM\n");
    }
}
int main(int argc, const char *argv[])
{
    if(signal(SIGALRM,hander)==SIG_ERR)//绑定SIGALRM信号
    {
        perror("signal");
        return -1;
    }
    unsigned int k = alarm(3);//设置3秒
    printf("k = %d\n",k);
    
    sleep(4);//睡1秒

    unsigned int m = alarm(5);//再次设定时间为5秒
    printf("m = %d\n",m);
    while(1);    
    return 0;
}

 实现斗地主

#include <myhead.h>
void hander(int sss)
{
    if(sss==SIGALRM)//捕获到信号
    {
        printf("系统为您自动出牌一张\n");
    }
    alarm(5);//重新设置定时时间
}
int main(int argc, const char *argv[])
{
    if(signal(SIGALRM,hander)==SIG_ERR)
    {
        perror("signal");
        return -1;
    }
    while(1)
    {
        alarm(5);//设定5秒的定时时间
        printf("请输入你要出的牌：");//输入出的牌
        char ch = fgetc(stdin);
        getchar();
        printf("您出的牌：%c\n",ch);
    }
    return 0;
}

 6、信号发送函数：kill raise

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

       int kill(pid_t pid, int sig);
        功能：发送信号给调用进程的函数，可以给自己发送信号也可以给其他进程发送信号
        参数1：进程号
        >0:向指定的进程号发送信号
        =0:向调用进程所在的进程组中每一个进程发送信号。
        =-1:向任意的进程发送信号
        <-1:向进程组ID为pid绝对值的所有进程发送信号。
        
        参数2：发送的信号号
        返回值：成功返回0，失败返回-1，并置位错误码。
         #include <signal.h>

       int raise(int sig);
        功能：调用进程向自己发送一个信号
        参数：信号号
        返回值：成功返回0，失败返回非0.

 原理：子进程向父进程发送一个信号（这个信号是自定义信号），父进程收到信号后，调用raise函数自杀。

#include <myhead.h>
void hander(int sss)
{
    printf("逆子啊，我要死了\n");
    raise(SIGKILL);//自杀
}
int main(int argc, const char *argv[])
{
    pid_t pid;
    pid = fork();
    if(pid>0)
    {
        if(signal(SIGUSR1,hander)==SIG_ERR)//父进程绑定了自定义信号
        {
            perror("signal");
            return -1;
        }
    }
    else if(pid==0)
    {
        kill(getppid(),SIGUSR1);//子进程向父进程发送自定义信号
    }
    else
    {
        perror("fork");
        return -1;
    }
    while(1);
    return 0;
}

 

luochen330x
关注
day06(进程间通信).rar
02-13
linux进程间通信代码部分，Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在...
精选资源
进程间通信（管道、消息队列、共享内存、信号量）.docx
07-22
"进程间通信（管道、消息队列、共享内存、信号量）" 进程间通信是计算机科学中的一种基本概念，它指的是在多个进程之间进行数据传输、资源共享、通知事件和进程控制等交流方式。由于进程的独立性，进程间的沟通变得...
day30 进程间通信
m0_72595899的博客
12-17 208
进程间通信信号的默认，忽略，捕获实现一遍。无名管道和有名管道实现一遍。
Linux学习——进程间通信
qq_52479948的博客
11-14 1277
Linux进程间通信
Day35 进程间通信IPC
hengheng114514的博客
02-26 1155
如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。(3)只有管道的读端存在时，向管道中写数据才有意义，否则会导致管道破裂，向管道中写入数据进程将收到内核传来的SIGPIPE信号（通常时Broken pipe错误）。系统默认对SIGALRM(闹钟到点后内核发送的信号)信号的响应： 如果不对SIGALRM信号进行捕捉或采取措施，默认情况下，闹钟响铃时刻会退出进程。2）信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件。
Linux系统编程 day6 进程间通信mmap
weixin_71568456的博客
04-19 714
var的时候 ：读时共享，写时复制父进程先创建映射区，指定共享MAP_SHARED权限 ， fork创建子进程。
day 24进程间通信—信号
2301_79909332的博客
08-10 722
3.SIGCHLD：表示该进程有一个子进程结束了。2.SIGUSR1：用户可以使用该信号实现通信。1.SIGSEGV：表示内核操作内存错误。4.SIGPIPE：表示管道破裂。3、不能被忽略和挂起的信号：9号和19号信号。1.SIGKILL 进程结束。2.SIGSTOP 进程挂起。一、信号：内核层和用户层通信的一种方式。1、缺省：按照默认的方式处理信号。3、捕捉：按照指定的方式处理信号。5、表示IO事件发生的信号。2、忽略：不处理信号。
Linux进程间通信
qq_33093885的博客
03-17 1286
Linux进程通信，基于文件的通信，匿名管道，命名管道
DAY8 IO 进程间通信
weixin_42019010的博客
09-15 158
DAY8 IO 进程间通信
Linux系统编程 day06 进程间通信
月仙儿的博客
11-28 1036
进程间通信的概念、匿名管道pipe、命名管道FIFO、内存映射区mmap
进程间通信的七种方式（一）
weixin_42197191的博客
09-27 9180
******************day05进程间通信********************** 进程间的7种通信方式          传统的通信方式：                                                有名管道                                                无名管道            ...
自学嵌入式 day30 IPC：进程间通信
2301_81142331的博客
07-03 2195
进程间通信：类别、管道：有名与无名、信号通信
进程、线程和进程间通信课件资料.zip
01-10
day1_1进程基础（基本概念）.pptx day1_2进程基础（常用命令）.pptx day1_3进程基础（进程的创建和结束）.pptx day1_4进程基础（进程的回收）.pptx day2_1进程基础（exec函数族）....day8_1进程间通信（信号机制）.pptx
Nmap 完整教学与 Linux 指令详解
2401_84359179的博客
01-03 1380
总结：Nmap 是网络安全领域的"瑞士军刀"，掌握 `-sS`、`-sV`、`-O`、`-A`、`-p`、`-T`、 `--script` 这 7 大核心参数，即可应对 90% 的扫描场景。1.权限 ：SYN 扫描 (`-sS`)、OS 检测 (`-O`)、UDP 扫描 (`-sU`) 需要 root 权限。3. 防火墙：现代 IDS/IPS 能检测 Nmap 扫描特征，需配合 `-T2`、`-f`、`-D` 等规避。初学者 ：从 `-sT`、`-sV`、`-p` 开始，逐步学习高级选项。
基于 Linux 内核模块的字符设备互斥访问实验
weixin_57340941的博客
12-30 532
这个信号量实验是。
Linux 防火墙配置详解：iptables 与 firewalld 的实战指南
A5互联
12-30 1169
在企业级 Linux 运维场景中，防火墙不仅是简单的“开关”，而是关系到网络安全性、业务可用性与性能边界的重要组件。本文以真实项目经验为基础，结合具体硬件配置、产品参数、代码示例和性能评估，全面讲解 `iptables` 与 `firewalld` 的架构差异、实战配置与优化方法，帮助你从一线配置走向深入的性能调优与安全设计。
Linux CFS 调度器深度解析
X
12-30 794
数学模型驱动: 用 vruntime 精确量化公平性简单性: 核心算法简洁优雅, 易于理解和维护自适应性: 自动适应不同负载和工作模式可扩展性: 通过组调度支持复杂场景表5: CFS 调度器的核心优势总结维度传统调度器CFS改进效果公平性基于优先级的时间片按权重的比例公平更精确的公平分配交互性需要启发式识别自然获得良好响应交互进程响应更快吞吐量固定时间片可能浪费动态调整, 减少切换整体吞吐量提升可配置性多个复杂参数主要调整 nice 值用户接口更简单代码维护复杂启发式逻辑。
Linux: network: ipv6: proxy_ndp
最新发布
mzhan017的博客
01-04 106
这意味着，如果一个主机 A 询问主机 B 的 MAC 地址，而主机 B 不在主机 A 的直接链路上，但有一个启用了 proxy_ndp 的中间设备 C 知道主机 B 的 MAC 地址，那么设备 C 就会代表主机 B 回复主机 A 的请求。桥接 (Bridging)：在某些复杂的桥接或虚拟化环境中，如果一个设备（如路由器或主机）需要为连接到其上的其他设备（如虚拟机或物理服务器）代理 NDP 消息，以确保它们能够被网络中的其他节点发现。将其值设置为 1 启用，设置为 0 禁用。
18. 操作系统-Linux-信创
princemilo的博客
12-30 961
在国家信创战略全面推进的大背景下，国产操作系统正加速替代国外系统，广泛应用于政企办公、关键基础设施、云计算、数据中心等核心领域。
深入解析Linux进程间通信机制与代码实现
在给定的文件标题 "day06(进程间通信).rar" 中，描述了Linux环境下实现IPC的基本原理。进程间需要交换数据时，通常需要借助内核来开辟一块共享的缓冲区，将数据从一个进程的用户空间拷贝到这块内核缓冲区，然后另一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值