进程间通信

最新推荐文章于 2021-07-30 15:38:58 发布
最新推荐文章于 2021-07-30 15:38:58 发布
阅读量203 收藏
点赞数
文章标签： linux 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CC_fighting/article/details/117637551
版权

进程间通信

因为不同的进程用户地址空间都是相互隔离的，但是内核空间是每一个进程共享的，所以进程间的通信必然通过内核（空间）。

linux下查看IPC使用情况：

ipcs

一、管道

1)匿名管道

匿名管道存在于内存之中，不能在文件系统中找到匿名管道

相关指令 |

比如： ps -ef|grep docker

相关函数

int pipe2(int pipefd[2], int flags);

创建一个匿名管道，返回两个描述符，一个用于读（fd[0]）,一个用于写（fd[1]）。创建的管道其实就是内核中的一段缓存。

匿名管道一般用于父子进程之间的通信，因为一个管道有读写端，所以一般在父子进程中分别关掉一端，一个管道只用来单方向通信，如果需要互相读写，则使用两个管道。

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

int main(int argc, char **argv)
{
    int pipefd[2];
    char buf;
    int pid;

    if (pipe(pipefd) == -1){
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    
    pid = fork();
    if (pid == -1){
        perror("fork");
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0){
        close(pipefd[1]);
        while(read(pipefd[0], &buf, 1)>0){
            write(STDOUT_FILENO, &buf, 1);
        }
        write(STDOUT_FILENO, "\n", 1);
        close(pipefd[0]);
        printf("Child exit\n");
        exit(EXIT_SUCCESS);
    }else{
        close(pipefd[0]);
        write(pipefd[1], "HAHAHAH", 7);
        close(pipefd[1]);
        wait(NULL);
        printf("Parent exit\n");
        exit(EXIT_SUCCESS);
    }

}

2)有名管道

相关指令

创建管道：

mkfifo test

写管道

echo "tests" > test

读管道

echo < test

相关函数

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

使用mkfifo创建管道文件，之后把它作为文件来进行读写就可以了。

匿名管道和有名管道的数据量是有一定限制的，linux下缓冲区大小为1页也就是4k，所以管道适合数据量很小的通信。而且当读写速度不一致时，读端会阻塞，写端当缓存满了之后也会阻塞，影响通信的效率。

二、消息队列

消息队列是保存在内核中的消息链表 ，进程间规定好消息体（自定义的结构体）。发送端发送消息之后，数据存在于消息队列链表中，读取消息队列按照发送的顺序读取，当读取完所有的消息之后，内核把这个消息体删除掉。

消息队列有大小限制，所有的消息体的总大小也有限制。所以不适用于大量数据的传递。而且消息队列存在用户态到内核态的数据拷贝开销。

相较于管道，消息队列是以消息为最小单位传输的，而管道是连续字节流数据。

相关函数

1、创建和获取一个消息队列

int msgget(key_t, key, int msgflg);

key用来标识一个消息队列

msgflg是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或操作，表示当key所命名的消息队列不存在时创建一个消息队列，如果key所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符。

返回值返回一个消息队列标识，失败返回-1

2、发送消息到消息队列

int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);

msgid使用msgget的返回值

msg_ptr是一个指向准备发送消息的指针，消息的结构体定义要求：

struct message{
	long int message_type;
	...
}

msgflg用于控制当前消息队列满或队列消息到达系统范围的限制时的操作

3、从消息队列获取消息

int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg);

4、消息队列操作

int msgctl(int msgid, int command, struct msgid_ds *buf);

command取值：

IPC_STAT：把msgid_ds结构中的数据设置为消息队列的当前关联值，即用消息队列的当前关联值覆盖msgid_ds的值。
IPC_SET：如果进程有足够的权限，就把消息列队的当前关联值设置为msgid_ds结构中给出的值
IPC_RMID：删除消息队列

buf是指向msgid_ds结构的指针，它指向消息队列模式和访问权限的结构。

示例

1、发送端

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/msg.h>

struct msg_st{
    long int msg_type;
    char msg[BUFSIZ];
};

int main()
{
    int msgid;
    struct msg_st snd_data;
    

    msgid = msgget((key_t)123, 0666|IPC_CREAT);
    if (msgid==-1){
        perror("msgget");
        exit(EXIT_FAILURE);
    }
    
    snd_data.msg_type = 11;
    strcpy(snd_data.msg, "testdata");
    
    if (msgsnd(msgid, (void*)&snd_data, BUFSIZ,0) == -1){
        perror("msgsnd");
        exit(EXIT_FAILURE);
    }
    
    exit(EXIT_SUCCESS);

}

2、接受端

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/msg.h>

struct msg_st{
    long int msg_type;
    char msg[BUFSIZ];
};

int main(){
    struct msg_st rcv_data;
    int msgid;
    int msg_type=0;

    msgid = msgget((key_t)123, 0666|IPC_CREAT);
    if (msgid==-1){
        perror("msgget");
        exit(EXIT_FAILURE);
    }
    
    if (msgrcv(msgid, (void*)&rcv_data, BUFSIZ,msg_type, 0) == -1){
        perror("msgrcv");
        exit(EXIT_FAILURE);
    }else{
        printf("%s\n",rcv_data.msg);
    }
    
    if (msgctl(msgid, IPC_RMID, 0) == -1){
        perror("remove msg");
        exit(EXIT_FAILURE);
    }
    
    exit(EXIT_SUCCESS);

}

三、共享内存

共享内存就是把两个进程的物理地址映射到同一块物理地址上，这样两个进程在同一块物理内存上操作，避免了用户态到内核态的拷贝开销。

但是共享内存也有一个问题就是，进程之间的读取需要手动完成同步的操作，一般使用信号量来进行同步访问控制。

相关函数

1、分配共享内存

int shmget(key_t key, size_t size,int shmflg);

创建或打开一块共享内存区

key：进程间通信键值，ftok() 的返回值。

size：该共享存储段的长度(字节)。

shmflg：标识函数的行为及共享内存的权限，其取值如下：

IPC_CREAT：如果不存在就创建

IPC_EXCL： 如果已经存在则返回失败

位或权限位：共享内存位或权限位后可以设置共享内存的访问权限，格式和 open() 函数的 mode_t 一样（open() 的使用请点此链接），但可执行权限未使用。

返回值：

成功：共享内存标识符。

失败：-1。

2、映射共享内存

void *shmat(int shmid, const void *shmaddr, int shmflg);

把一段已经分配好的共享内存映射到进程的数据段中。

shmid：共享内存标识符，shmget() 的返回值。

shmaddr：共享内存映射地址(若为 NULL 则由系统自动指定)，推荐使用 NULL。

shmflg：共享内存段的访问权限和映射条件( 通常为 0 )，具体取值如下：

0：共享内存具有可读可写权限。

SHM_RDONLY：只读。

SHM_RND：（shmaddr 非空时才有效）

返回值：

成功：共享内存段映射地址( 相当于这个指针就指向此共享内存 )

失败：-1

3、解除共享内存的映射

int shmdt(const void *shmaddr);

把映射到共享内存的地址解除映射。

shmaddr：共享内存映射地址。

返回值：

成功：0

失败：-1

4、控制共享内存

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

shmid：共享内存标识符。

cmd：函数功能的控制，其取值如下：

IPC_RMID：删除。(常用 )

IPC_SET：设置 shmid_ds 参数，相当于把共享内存原来的属性值替换为 buf 里的属性值。

IPC_STAT：保存 shmid_ds 参数，把共享内存原来的属性值备份到 buf 里。

SHM_LOCK：锁定共享内存段( 超级用户 )。

SHM_UNLOCK：解锁共享内存段。

buf：shmid_ds 数据类型的地址(具体类型请点此链接 )，用来存放或修改共享内存的属性。

返回值：

成功：0

失败：-1

示例

1、写内存端

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

struct shared_st
{
    int writeable;
    char data[BUFSIZ];
};

int main(){
    int shmid;
    void *shm=NULL;
    struct shared_st *data=NULL;

    shmid = shmget((key_t)123, sizeof(struct shared_st), 0666|IPC_CREAT);
    if (shmid == -1){
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    shm=shmat(shmid, 0,0);
    if (shm == (void*)-1){
        perror("shmat");
        exit(EXIT_FAILURE);
    }
    
    printf("shared address %X\n", (int)shm);
    
    data = (struct shared_st*)shm;
    
    while(data->writeable!=1){
        sleep(1);
    }
    
    strcpy(data->data, "A message from writer\n");
    data->writeable = 0;
    
    if(shmdt(shm) == -1)   
    {      
        perror("shmdt");  
        exit(EXIT_FAILURE);
    }
    
    exit(EXIT_SUCCESS); 

}

2、读内存端

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

struct shared_st
{
    int writeable;
    char data[BUFSIZ];
};

int main(){
    int shmid;
    void *shm=NULL;
    struct shared_st *data=NULL;

    shmid = shmget((key_t)123, sizeof(struct shared_st), 0666|IPC_CREAT);
    if (shmid == -1){
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    
    shm=shmat(shmid, 0,0);
    if (shm == (void*)-1){
        perror("shmat");
        exit(EXIT_FAILURE);
    }
    
    printf("shared address %X\n", (int)shm);
    
    data = (struct shared_st*)shm;
    data->writeable = 1;
    
    while(data->writeable!=0){
        sleep(1);
    }
    
    if (strlen(data->data)>0){
        printf("read data %s\n",data->data);
    }
    
    if (shmdt(shm)==-1){
        perror("shmdt");
        exit(EXIT_FAILURE);
    }
    
    if (shmctl(shmid, IPC_RMID, 0)==-1){
        perror("remove shm");
        exit(EXIT_FAILURE);
    }
    
    exit(EXIT_SUCCESS);

}

四、信号量

在使用共享内存的时候遇到数据同步的问题，可以使用信号量来解决。信号量主要用于进程间的互斥和同步，而不能用来传输数据。

信号量的两种操作

P：如果sv的值大于0则减一，如果sv值为0，则进程挂起

V：如果有其他的进程因为等待sv而挂起，则使它恢复运行，如果没有，则sv值加一

sv初始值为1

相关函数（System V）

（还有sem_init的一套函数（POSIX信号量），一般用于线程同步）

1、创建或者获取一个信号量

int semget(key_t key, int num_sems, int sem_flags);

key:信号量键值，可以理解为信号量的唯一性标记，可通过ftok获取。
num_sems:信号量的数目，一般为1，如果只是访问不创建可以为0.
sem_flags:有两个值，IPC_CREATE和IPC_EXCL，
IPC_CREATE表示若信号量已存在，返回该信号量标识符。
IPC_EXCL表示若信号量已存在，返回错误。

返回值：相应的信号量标识符，失败返回-1

2、改变信号量的值

int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);

**sem_id:**信号量标识符
sem_opa:结构如下

struct sembuf{  
    short sem_num;//除非使用一组信号量，否则它为0  
    short sem_op;//信号量在一次操作中需要改变的数据，通常是两个数，一个是-1，即P（等待）操作，  
                    //一个是+1，即V（发送信号）操作。  
    short sem_flg;//SEM_UNDO：当操作的进程退出后，该进程对sem进行的操作将被取消；
    	          //IPC_NOWAIT:在对信号量的操作不能执行的情况下，该操作立即返回；
    			  //0:在对信号量的操作不能执行的情况下，该操作阻塞到可以执行为止
};

3、信号量初始化和删除

int semctl(int sem_id,int sem_num,int command,[union semun sem_union]);

command:有两个值SETVAL,IPC_RMID，分别表示初始化和删除信号量。
sem_union:可选参数，结构如下：

union semun{  
    int val; 
    struct semid_ds *buf;  
    unsigned short *arry;  
};

五、信号

查看linux下所有的信号：

kill -l

当进程接收到信号的时候，处理方式如下：

1）执行默认操作。对大多数的信号系统的默认处理方式就是终止进程。

2）捕获信号。当定义了信号处理函数的时候，会捕获信号并执行对应的处理函数。

比如：

void handler(int sig) 
{  
	printf("%d\n",sig); 
} 

int main() 
{   
	signal(SIGINT,fun);  
    ...
}

3）忽略信号。

比如：

signal(SIGINT, SIG_IGN);

其中，SIGKILL和SIGSTOP是不可以被捕获或者忽略的。

六、Socket

当互相通信的进程有可能不部署在同一台机器的时候，最好使用socket来通信。

x_cc
关注
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
共享内存 --- shm
aLingYun的博客
09-03 2615
共享内存是进程间通信中最简单的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其它进程都会察觉到这个更改。其特点是： 共享内存是进程间共享数据的一种最快的方法。一个进程向共享的内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容。 使用共享内存要注意的是多个...
进程间通信 之 共享内存
XHW___001的博客
04-09 198
进程间通信 之 共享内存一 概述二 优势三 劣势四 函数1 shmget2 shmat3 shmdt4 shmctl 一 概述 共享内存是进程间通信中最简单的方式之一。共享内存允许两个或更多进程访问同一块内存，就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。当一个进程改变了这块地址中的内容的时候，其它进程都会察觉到这个更改。 二 优势 1 ipc通信中最快的一种方式。   原因：两个进程地址通过页表映射到同一片物理地址，进程传递的数据直接从内存里存取、放入，数据不需要在两进程间复
Linux：虚拟地址空间&写时拷贝
qq_45481606的博客
07-30 339
1.fork函数： 见前面写的fork函数 2. 写时拷贝： 通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本 图片来源比特教育 当父进程创建子进程后，父子进程通过页表结构映射到同一块物理内存，当两个进程对物理内存区域的值都不修改的时候，它们各自的进程虚拟地址与物理内存的映射关系是一致没有改变的; 当其中一个进程修改数据的时候，操作系统才会去修改这个进程的映射关系（属于深拷贝） fork函数在拷贝时也拷贝了页表关系，父子进程的全局变量值都在各自数
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
C#使用SendMessage实现进程间通信的方法
09-03
在C#编程中，进程间通信（IPC，Inter-Process Communication）是一种允许不同进程之间交换数据的技术。在本文中，我们将探讨如何使用Windows API中的`SendMessage`函数在两个C#进程中实现这一通信方式。 `...
进程间通信_进程间通信_
09-28
进程间通信（IPC，Inter-Process Communication）是操作系统中一种重要的技术，允许不同的进程之间交换数据、协调工作。在C#编程中，实现进程间通信有很多种方法，每种方法都有其适用场景和优缺点。本篇文章将深入...
Linux进程间通信
05-20
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程之间共享数据、交换信息的一种机制。它是多任务环境下实现协作和同步的重要手段。Linux提供了多种进程间通信方式，包括管道（Pipe）、...
Messenger进程间通信
03-15
在Android系统中，进程间通信（IPC，Inter-Process Communication）是实现不同应用程序或同一应用内不同进程之间数据共享和协同工作的重要手段。"Messenger进程间通信"是一种轻量级的IPC方式，常用于简单的双向通信...
C语言实现进程间通信原理解析
08-19
主要介绍了C语言实现进程间通信原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
进程间通信详解.txt
10-11
面试题目，大公司笔试，行业内最新资讯，优秀的教学资源，很多很详细的例子，非常有助于学习道路上前进，并且是最经典的例子，最经典的教材
C# 使用管道Pipe在进程间通信
03-25
进程间通信的一种方式，Pipes：管道，分为无名管道：在父子进程间交换数据；有名管道：可在不同主机间交换数据，分为服务器方和客户方，在Win9X下只支持有名管道客户。 1、进程间通信 2、管道Pipe通信
Windows进程间通信
08-02
在Windows操作系统中，进程间通信（IPC，Interprocess Communication）是一种技术，允许不同的进程之间共享数据、协调工作或交换信息。这种技术对于多线程和多进程应用的开发至关重要，尤其是在分布式系统和并发编程...
Qt进程间通信与同步示例
04-29
在Qt框架中，进程间通信（IPC，Inter-Process Communication）和进程同步是两个关键概念，用于在多个独立运行的程序之间交换数据和协调执行。本示例将深入讲解如何利用Qt库中的特性来实现这些功能，特别是通过QFile...
chat_进程间通信_
10-02
在IT领域，进程间通信（IPC，Inter-Process Communication）是一种关键的技术，它允许不同的进程之间交换信息，协同工作。本文将深入探讨“聊天”场景下的进程间通信，包括私聊、群聊以及数据传输与共享内存，以及...
进程间通信例子
08-18
进程间通信（Inter-Process Communication, IPC）是操作系统中一种重要的技术，允许不同进程之间交换数据和信息。在Windows环境中，实现进程间通信有多种方式，包括但不限于管道、消息队列、共享内存、套接字、命名...
windows 与linux 进程间通信区别
06-01
在操作系统中，进程间通信（IPC）是一种允许不同进程之间进行数据交换和同步操作的重要机制。Windows和Linux作为当前主流的操作系统平台，它们在进程间通信方面有着各自的实现方式和特点。为了帮助开发者了解如何将...
Linux-进程间通信
10-07
Linux进程间通信是操作系统中进程之间交换信息的重要方式。它涉及多个机制，包括管道、消息队列、信号量、共享内存、套接字和信号。这些机制各具特点，适用于不同的场景。 1. **管道**：管道分为无名管道和命名管道...
Linux进程间通信详解
"该资源为一份关于Linux进程间通信的PDF文档，由孙天泽于2006.3年撰写，主要介绍了Linux系统中的进程通信机制，适用于嵌入式Linux应用程序开发的学习与实践。文档内容包括Linux进程、内核开发、驱动程序开发以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值