进程间的通信（Linux）

最新推荐文章于 2024-06-17 17:40:34 发布
最新推荐文章于 2024-06-17 17:40:34 发布
阅读量397 收藏
点赞数 6
文章标签： 服务器 linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50646640/article/details/126270610
版权

目录

1、管道

（1）无名管道

  1）无名管道的创建 --pipe()

  2）无名管道的读写特性

（2）、有名管道

2、信号

（1）常用信号

（2）信号相关指令

（3）信号相关接口函数 -- kill

（4）定时器

（5）捕获信号 -- signal

 

进程间通信机制： 

unix继承：管道、信号

system V IPC对象：共享内存、消息队列、信号灯集

                                套接字

 

1、管道

管道分为无名管道和有名管道 -- 区别在于创建的管道能否在文件系统中可见

（1）无名管道

特点：

1、在创建之后在文件系统中不可见

2、以半双工的方式进行通信

3、拥有固定的读端和写端

4、只能用于具有亲缘关系的进程间通信

  1）无名管道的创建 --pipe()

       #include <unistd.h>

       int pipe(int pipefd[2]);
参数：
    pipefd:存放无名管道读端和写端的数组首地址
        pipefd[0] -- 读端
        pipefd[1] -- 写端
返回值：
    成功返回0，失败返回-1

 练习：在一个进程中创建一个子进程，子进程从键盘获取数据，父进程打印输出

 代码示例：

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

int main(int argc, char *argv[])
{
    int fd[2] = {0};//定义无名管道读写端的数组
    int ret = pipe(fd);//创建无名管道
    if(ret < 0)
        {
        perror("pipe");
        exit(-1);
    }
    
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork");
        exit(-1);
    }
    if(pid == 0)//子进程
    {
        while(1)
        {
            char buf[64] = {0};
            fgets(buf,64,stdin);
            buf[strlen(buf)-1] = '\0';
            write(fd[1],buf,strlen(buf));
        }
        exit(0);
    }
    else//父进程
    {
        while(1)
        {
            char buf1[64] = {0};
            memset(buf1,0,64);
            read(fd[0],buf1,64);
            printf("%s\n",buf1);
        }
    }
    wait(NULL);
    exit(0);

    return 0;
}

运行结果： 

  2）无名管道的读写特性

读特性：

        写端存在：如果管道有数据，返回读到的字节数

                          如果管道无数据，阻塞

        写端不存在：如果管道有数据，返回读到的字节数

                             如果管道无数据，返回0

写特性：

        读端存在：如果管道有空间，返回写入的字节数

                          如果管道无空间，阻塞，直到有空间为止

        读端不存在：

                          无论管道是否有空间，管道破裂（向进程发送管道破裂信号，结束进程）

 

练习：1、计算无名管道空间大小

           2、验证管道破裂

代码示例：

1、

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

int main(int argc, char *argv[])
{
    int fd[2];
    int ret = pipe(fd);
    if(ret < 0)
    {
        perror("pipe");
        exit(-1);
    }
    int size = 0,m = 0;
    while(1)
    {
        char buf[1024] = {0};
        size_t m = write(fd[1],buf,1024);//往管道里写数据，返回字节数
        size = size + m;
        printf("%d\n",size);
    }


    return 0;
}

2、

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

int main(int argc, char *argv[])
{ 
    int pfd[2] = {0};
    int ret = pipe(pfd);   //创建无名管道
    if(ret < 0)
    {
        perror("pipe");
        exit(-1);
    }

    close(pfd[0]);         //关闭无名管道的读端
    pid_t pid = fork();     //创建子进程

    if(pid == 0)
    {
        write(pfd[1], "hello", 5);
        
        sleep(5);
    }
	else
	{
		int status;
		wait(&status);
		
		printf("%d %d %d\n", WIFEXITED(status),WIFSIGNALED(status),WTERMSIG(status));
		
		exit(0);
	}

    return 0;
}

运行结果： 

 

 

（2）、有名管道

有名管道创建之后会在文件系统中以管道文件的形式存在

有名管道可以用于任意两个进程之间的通信，没有固定的读端和写端

 (1)有名管道的创建 -- mkfifo

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

       int mkfifo(const char *pathname, mode_t mode);

参数：
    pathname：创建管道文件的文件名
    mode：创建管道文件的权限
返回值：
    成功返回0，失败返回-1

练习：创建一个有名管道，一个进程向管道中输入数据，另一个进程输出数据

1、创建有名管道

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{ 
    int ret = mkfifo("fifo", 0664);
    if(ret < 0)
    {
        perror("mkfifo");
        exit(-1);
    }


    return 0;
}

 2、创建进程

进程1：

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

int main(int argc, char *argv[])
{ 
    int fd = open("fifo", O_RDONLY);
    if(fd < 0)
    {
        perror("open");
        exit(-1);
    }
    
    printf("open fifo ok!\n");

    char buf[64] = {0};
    while(1)
    {
        memset(buf, 0, 64);
        read(fd, buf, 64);
        printf("%s\n", buf);
    }

    close(fd);
    return 0;
}

进程2：

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

int main(int argc, char *argv[])
{ 
    int fd = open("fifo", O_WRONLY);
    if(fd < 0)
    {
        perror("open");
        exit(-1);
    }
    
    printf("open fifo ok!\n");

    char buf[64] = {0};
    while(1)
    {
        fgets(buf, 64, stdin);
        buf[strlen(buf)-1] = '\0';

        write(fd, buf, strlen(buf));
    }

    close(fd);
    return 0;
}

2、信号

信号：是中断在软件层次上的一种模拟

信号的处理方式：

默认处理

忽略

捕获信号

 

（1）常用信号

（2）信号相关指令

kill -l :查看当前系统中的所有信号

kill -信号编号 进程号：向指定进程发送对应编号的信号

例：

kill -9 1234：向进程1234发送信号9

kill -9 -1234：向进程组1234发送信号9

kill -9 -1 ：向除了init进程以外的其他所有进程发送信号9

（3）信号相关接口函数 -- kill

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

       int kill(pid_t pid, int sig);

参数：
    pid：指定进程号
    sig：指定信号
返回值：
    成功返回0，失败返回-1；
    
-------------------------------------------------

       #include <signal.h>

       int raise(int sig);

参数：
    sig：指定信号
    
返回值：
    成功返回0，失败返回非零值

（4）定时器

定时时间到时，当前进程会接受到编号为14的信号 -- SIGARLM

一个进程中最多只能存在一个定时器

定时器相关函数 -- alarm

       #include <unistd.h>

       unsigned int alarm(unsigned int seconds);

参数：
    seconds：定时秒数
返回值：
    成功返回0或者上个定时器定时剩余的时间
    
-------------------------------------------------
    
       #include <unistd.h>

       int pause(void);
功能：阻塞在当前位置，等待定时结束

（5）捕获信号 -- signal

       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);

参数：
    signum：指定信号
    handler：信号处理函数
			SIG_IGN:选择以忽略方式处理指定信号
            SIG_DFL:选择以默认方式处理指定信号

练习：创建一个子进程，子进程结束时，父进程提示子进程退出信息

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
void func(int num);
int main(int argc, char *argv[])
{ 
    pid_t pid = fork();
    
    if(pid == 0)
    {
        printf("aaaaaaaa\n");
        exit(0);
    }
    else
    {
        signal(17, func);
        while(1)
        {
            printf("bbbbbbbbbbb\n");
            sleep(1);
        }

    }


    return 0;
} 

void func(int num)
{
    printf("child leave!\n");
    raise(9);
}

逆倪
关注
Linux-进程间通信
AI_ELF的博客
08-23 6924
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
Linux进程控制：wait获取子进程退出状态 WIFEXITED和WIFSIGNALED用法
weixin_44498318的博客
08-24 1176
可以使用wait函数传出参数status来保存进程的退出状态。 常用宏函数分为日如下几组： 1、 WIFEXITED(status) 若此值为非0 表明进程正常结束。 若上宏为真，此时可通过WEXITSTATUS(status)获取进程退出状态(exit时参数) 示例： if(WIFEXITED(status)){ printf("退出值为 %d\n", WEXITSTATUS(status)); } 2、 WIFSIGNALED(status)为非0 表明进程异常终止。 若上宏为
linux 系统篇 - 五、深入 linux 进程
sty01z的博客
06-13 101
这个进程树的局部向我们表明, 当前的命令行进程 bash(2069) 创建了父进程 a.out(2304), 该父进程创建了 3 个子进程 a.out(2305)/(2306)/(2307). 而当前命令行竟然将 3 个子进程打印出来了, 这说明。可以看到, 这几个进程之间的关系, 接下来等待子进程结束运行. 子进程运行结束后再打印进程表。可以看到有 7 个进程在运行, 其中一个父进程一个子进程, 5 个孙进程, 于是打印进程树。子进程现在是僵尸进程, 而五个进程还是存在的. 于是打印进程树。
linux 进程学习
qq_51452762的博客
04-25 222
【代码】linux 进程学习。
【Linux】僵尸进程|wait&waitpid函数详解
最新发布
代码兴国
06-17 1234
🔥❤️僵尸进程（Zombie Process）是指一个已经完成执行（终止）的子进程，在父进程没有调用wait()或waitpid()来获取子进程的终止状态之前，该子进程的进程描述符仍然存在于系统中的状态。
Linux —— 进程控制
NapoleonCoder的博客
08-03 294
进程控制；
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
Linux进程间通信方式之socket使用实例
09-15
### Linux进程间通信方式之socket使用实例详解 #### 一、引言 在现代操作系统中，进程间的通信（IPC）是实现多进程协同工作的重要手段之一。Linux提供了多种进程间通信的方法，包括信号量、消息队列、共享内存以及...
Linux·进程相关概念知识点
m0_64560763的博客
08-09 254
Linux进程基础知识点
WIFEXITED/WEXITSTATUS/WIFSIGNALED
duanxuyun的专栏
12-01 2471
http://hi.baidu.com/adane/blog/item/154c0cd7ca893ed8a044df40.htmlWIFEXITED/WEXITSTATUS/WIFSIGNALED2008-06-13 15:07If the exit status value (*note Program Termination::) of the childpro
wait获取子进程退出状态 WIFEXITED和WIFSIGNALED用法
希哈科技
02-01 923
可以使用wait函数传出参数status来保存进程的退出状态。 常用宏函数分为日如下几组：  1、 WIFEXITED(status) 若此值为非0 表明进程正常结束。  若上宏为真，此时可通过WEXITSTATUS(status)获取进程退出状态(exit时参数)  示例： if(WIFEXITED(status)){ printf("退
WIFEXITED WIFSTOPPED WIFSIGNALED用法
zuihoudebingwen的专栏
03-09 2193
waitpid()介绍】waitpid主要用于根据进程ID号等待指定的子进程。函数形式如下：******************************************************pid_t waitpid(pid_t pid, int* status,int options)；**************************************************
Linux 进程———详解
m0_51551385的博客
04-28 370
1、各种进程相关的基本概念 1.1 区分程序和进程 程序： 是存储在存储设备（磁盘）上的数据，包含了可执行机器指令（二进制代码）和数据的静态实体。我们说程序不占用系统资源，这里的系统资源指CPU、内存等，但是不包括磁盘 进程： 运行的程序会变成进程，是已经被 OS 从磁盘加载到内存上的、动态的、可运行的指令与数据的集合 1.2 MMU 内存管理单元 存在于CPU中，他有两个功能： ① 完成虚拟内存地址到物理内存地址的映射 ② 设置 / 修改内存的访问级别 1.3 虚拟内存 运行一个程序，产生进程的同时产生一
wait, WIFEXITED, WEXITSTATUS
kissinger_1984的专栏
05-25 849
偶尔翻到了这几个关键字，找到个文章复习了下：“点我”。记录下：wait的函数原型是： #include &lt;sys/types.h&gt; /* 提供类型pid_t的定义 */ #include &lt;sys/wait.h&gt; pid_t wait(int *status)进程一旦调用了wait，就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已...
Linux学习笔记二
baidu_41553551的博客
05-16 802
上接笔记一 文件权限 文件属于某一个人的，但可能
linux : waitpid函数
10-13 9283
【waitpid系统调用】       功能描述： 等待进程改变其状态。所有下面哪些调用都被用于等待子进程状态的改变，获取状态已改变的子进程信息。状态改变可被认为是：1.子进程已终止。2.信号导致子进程停止执行。3.信号恢复子进程的执行。在子进程终止的情况下，wait调用将允许系统释放与子进程关联的资源。如果不执行wait，终止了的子进程会停留在"zombie"状态。如果发现子进程改变了状
进程间通信linux
08-18
进程间通信（IPC）在Linux系统中是非常重要的。IPC是指不同进程之间传输或交换信息的机制。其目的可以分为几个方面。首先，它用于数据传输，一个进程需要将它的数据发送给另一个进程。其次，IPC用于资源共享，多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值