Linux--进程间通信

最新推荐文章于 2022-08-06 10:40:56 发布
最新推荐文章于 2022-08-06 10:40:56 发布
阅读量226 收藏
点赞数
分类专栏： 进程 进程间通信 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccbbird/article/details/108346402
版权

系统是以进程进行工作的的，进程的地址空间是独立的，进程之间有可能需要数据交互

进程间通信：
1.管道：有名管道 无名管道
2.信号量
3.消息队列
4.共享内存

管道

1.有名管道（半双工通讯）

单工通信
半双工通讯
全双工通讯

有名管道：在磁盘空间会有一个管道文件标识（inode节点），只要是有权限操作这个管道文件的进程，都可以利用其和其他进程进行数据交互

有名管道虽然在磁盘上有管道文件标识，但在使用管道文件来进行进程通信时，数据会被缓存到内存上，并不会占据磁盘的block区域

有名管道的使用
创建管道文件：
命令 mkfifo filename — 》创建一个管道文件
系统调用 int mkfifo(const char*pathname , mode_t mode);

打开管道文件 open 会阻塞，只有读打开或者只有写打开
写数据 write 有读存在，管道没空余空间，阻塞
读数据 read 有写端存在，但是管道中没有数据，read阻塞
关闭 close
示例：A进程向B进程发送“hello world”，B进程打印
在这里插入图片描述
在这里插入图片描述

2.无名管道（无管道文件）

数据也是缓存在内存上，也是半双工通讯

借助的是fork时，父子进程共享fork之前打开的文件描述符
限制：只能应用在有关系的进程之间：父子，兄弟
创建并打开无名管道：
int pipe(int fds[2]);需要两个整型变量
pipe方法调用成功，传递的参数：
fds[0]：指向管道的读端
fds[1]：指向管道的写端
使用：read write close

示例：在这里插入图片描述
在这里插入图片描述

信号量

相关概念

  1. 临界资源：同一时刻，只能被一个进程访问的资源
  2. 临界区：程序中访问临界资源的代码区域
  3. 原子操作：不能被分割执行，一旦开始就必须结束
  4. PV操作：P操作进行-1，V操作进行+1操作

信号量时进行进程间同步执行控制的一种手段
直接制约关系：一个进程为另一个进程提供数据
间接制约关系：两个进程竞争临界资源

信号量：是一种特殊的计数器，当信号量大于零时，记录的是临界资源的个数，当信号量等于零时，对信号量执行P操作，则P操作阻塞，当一个进程释放使用的临界资源，是对信号量执行V操作

特殊信号量：二元信号量–》它的值只能是0或者1

信号量使用：
多个进程需要操作的是同一个信号量，信号量必须存储在这些进程能够共享的位置–》系统内核–内核对象：操作系统内核标识：1.ID整型值。2.为使多个进程能够汇合到同一个IPC对象上，有一个外部名：键值（key）

  1. 创建或者获取 在这里插入图片描述

  2. 初始化–》只有创建时，才需要 在这里插入图片描述

  3. P操作–》进程进入临界区前 在这里插入图片描述

  4. V操作–》进程结束临界区后 在这里插入图片描述

  5. 销毁信号量 在这里插入图片描述

封装成

  1. 创建并初始化或者获取一个信号量
  2. 执行P操作的方法
  3. 执行V操作的方法
  4. 销毁信号量的方法

例题：进程a和进程b模拟访问打印机，进程a输出第一个字符‘a’表示开始使用打印机，输出第二个字符‘a’表示结束使用，b进程操作与a进程相同（打印机仅有一台且同一时刻只能被一个进程使用，所以输出结果应该成对出现，例如aabb）

在这里插入图片描述
封装方法的头文件

#pragma once
typedef union semun
{
	int val;
}SemUn;
int GetSem(int key, int initval);

int DelSem(int semid);

int SemP(int semid);

int SemV(int semid);

方法实现

#include "sem.h"
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>

int GetSem(int key,int initval)
{
	int semid = semget((key_t)key , 0, 0664);
	if(semid == -1)
	{
		semid = semget((key_t)key, 1, 0664 | IPC_CREAT);
		if(semid == -1)
		{
			return -1;
		}

		SemUn data;
		data.val = initval;
		int res = semctl(semid, 0, SETVAL, data);
		if(res == -1)
		{
			DelSem(semid);
			return -1;
		}
	}
	return semid;
}

int SemP(int semid)
{
	struct sembuf buf;
	buf.sem_num = 0;
	buf.sem_op = -1;
	buf.sem_flg = SEM_UNDO;

	int res = semop(semid,  &buf, 1);
	if(res == -1)
	{
		return -1;
	}

	return 0;
}

int SemV(int semid)
{
	struct sembuf buf;
	buf.sem_num = 0;
	buf.sem_op = 1;
	buf.sem_flg = SEM_UNDO;

	int res = semop(semid, &buf, 1);
	if(res == -1)
	{
		return -1;
	}
	return 0;
}

int DelSem(int semid)
{
	int res = semctl(semid, 0, IPC_RMID);
	if(res == -1)
	{
		return -1;
	}
	return 0;
}

进程a程序

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <fcntl.h>
#include <signal.h>

#include "sem.h"

int main()
{
	srand((unsigned int)time(NULL) * time(NULL));
	int semid = GetSem(1234, 1);

	assert(semid != -1);

	int count = 0;
	while(1)
	{
		SemP(semid);

		printf("a");
		fflush(stdout);

		int n = rand() % 4;
		sleep(n);

		printf("a");
		SemV(semid);
		fflush(stdout);

		count ++;
		if(count == 10)
			break;
		n = rand() % 3;
		sleep(n);

	}
	exit(0);
}

进程b程序

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <fcntl.h>
#include <signal.h>

#include "sem.h"

int main()
{
	srand((unsigned int)time(NULL) * time(NULL));
	int semid = GetSem(1234, 1);

	assert(semid != -1);

	int count = 0;
	while(1)
	{
		SemP(semid);

		printf("b");
		fflush(stdout);

		int n = rand() % 4 + 1;
		sleep(n);

		printf("b");
		SemV(semid);
		fflush(stdout);

		count ++;
		if(count == 10)
			break;
		n = rand() % 3 + 1;
		sleep(n);

	}
	exit(0);
}

最终执行结果
在这里插入图片描述
ipcs -s 查看当前系统上的信号量集
ipsrm -s semid 删除系统上的信号量集

消息队列

消息：消息是按照条进行计算的，消息是类型+数据的组合
队列：先进先出的数据结构
在这里插入图片描述
读取消息的进程可以根据类型（选择性）来读取消息（蓝色块类型，橙色块数据）
在同种类型上，读取消息按照先进先出的原则读取

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

进程a

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <fcntl.h>
#include <signal.h>

#include <sys/msg.h>
#include <sys/types.h>
#include <sys/ipc.h>

typedef struct msgbuf
{
	long mtype;
	char mtext[128];
}msgbuf;

int main()
{
	int msgid = msgget((key_t)1234, IPC_CREAT | 0664);
	assert(msgid != -1);

	msgbuf buf;
	memset(&buf, 0 ,sizeof(buf));
	buf.mtype = 100;
	
	strcpy(buf.mtext, "hello world");

	msgsnd(msgid, &buf, strlen(buf.mtext), 0);
	exit(0);
}

进程b

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <fcntl.h>
#include <signal.h>

#include <sys/msg.h>
#include <sys/types.h>
#include <sys/ipc.h>

typedef struct msgbuf
{
	long mtype;
	char mtext[128];
}msgbuf;

int main()
{
	int msgid = msgget((key_t)1234, IPC_CREAT | 0664);
	assert(msgid != -1);

	msgbuf buf;
	
	memset(&buf, 0 ,sizeof(buf));

	msgrcv(msgid, &buf, 127, 100, 0);

	printf("mtype = %d, mtext = %s\n",buf.mtype,buf.mtext);
	exit(0);
}

执行结果：

在这里插入图片描述

共享内存

（最快的IPC）
在这里插入图片描述
管道通过文件系统机制，共享内存不是

1.先申请一块物理内存空间，有共享内存的内核对象来保存
2.各个进程分别将自己的一块虚拟地址空间通过共享内存的内核对象映射到物理内存空间上
3.可以直接通过映射的首地址来访问这块空间
在这里插入图片描述

在这里插入图片描述
返回值是地址空间的首地址
在这里插入图片描述

在这里插入图片描述
示例：
进程a从键盘获取数据并拷贝到共享内存中，进程b从共享内存中获取并打印数据。要求进程a输入一次，进程b输出一次，a不输入，b不输出。
sem.h

#pragma once
typedef union semun
{
	int val;
}SemUn;
int GetSem(int key, int initval[],int n);

int DelSem(int semid);

int SemP(int semid,int index);

int SemV(int semid,int index);

sem.c

#include "sem.h"
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>

int GetSem(int key,int initval[], int n)
{
	int semid = semget((key_t)key , 0, 0664);
	if(semid == -1)
	{
		semid = semget((key_t)key, n, 0664 | IPC_CREAT);
		if(semid == -1)
		{
			return -1;
		}

		int i = 0;
		for(; i < n;++i)
		{
			SemUn data;
			data.val = initval[i];
			int res = semctl(semid, i, SETVAL, data);
			if(res == -1)
			{
				DelSem(semid);
				return -1;
			}
		}
	}
	return semid;
}

int SemP(int semid, int index)
{
	struct sembuf buf;
	buf.sem_num = index;
	buf.sem_op = -1;
	buf.sem_flg = SEM_UNDO;

	int res = semop(semid,  &buf, 1);
	if(res == -1)
	{
		return -1;
	}

	return 0;
}

int SemV(int semid, int index)
{
	struct sembuf buf;
	buf.sem_num = index;
	buf.sem_op = 1;
	buf.sem_flg = SEM_UNDO;

	int res = semop(semid, &buf, 1);
	if(res == -1)
	{
		return -1;
	}
	return 0;
}

int DelSem(int semid)
{
	int res = semctl(semid, 0, IPC_RMID);
	if(res == -1)
	{
		return -1;
	}
	return 0;
}

shma.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <fcntl.h>
#include <signal.h>

#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include "sem.h"

int main()
{
	int initval[] = {1, 0};
	int semid = GetSem(1234, initval, 2);
	assert(semid != -1);
	int shmid = shmget(1234, 128, IPC_CREAT | 0664);
	assert(shmid != -1);

	char *ptr = (char *)shmat(shmid, NULL, 0);
	assert(ptr != (char *)-1);

	while(1)
	{
		SemP(semid, 0);
		printf("input:");
		fgets(ptr, 127, stdin);

		SemV(semid,1);
		if(strncmp(ptr, "end", 3) == 0)
			break;
	}
	shmdt(ptr);

	shmctl(shmid, IPC_RMID, NULL);
	exit(0);
}

shmb.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <fcntl.h>
#include <signal.h>

#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include "sem.h"

int main()
{
	int initval[] = {1, 0};
	int semid = GetSem(1234, initval, 2);
	assert(semid != -1);
	int shmid = shmget(1234, 128, IPC_CREAT | 0664);
	assert(shmid != -1);

	char *ptr = (char *)shmat(shmid, NULL, 0);
	assert(ptr != (char *)-1);

	while(1)
	{
		SemP(semid, 1);

		if(strncmp(ptr, "end", 3) == 0)
			break;
		printf("B: %s",ptr);
		memset(ptr, 0 ,128);
		SemV(semid,0);
	}
	shmdt(ptr);

	shmctl(shmid, IPC_RMID, NULL);
	DelSem(semid);
	exit(0);
}

执行结果：
在这里插入图片描述

ipcs -s -q -m 查看
ipcrm -s -q -m 删除
Wavesgf
关注
专栏目录
Linux高级编程基础——进程间通信之共享内存
那个那的博客
11-11 620
进程间通信之共享内存 创建共享内存，写进程每隔2秒向内存写入一次“hello world”； 如果结束写操作，则写进程写入“end”； 读进程从共享内存读取数据，并打印。直到读到“end”为止。 这是写进程 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;sys/ty...
Linux-进程间通信
AI_ELF的博客
08-23 6877
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
【操作系统】-PV操作
Jack 架构师之路
04-03 1663
基本概念     临界区：我们把并发进程中与共享变量有关的程序段称为临界区。     进程的同步：指在并发进程之间存在一种制约关系，一个进程的执行依赖另一个进程的消息，当一个进程没有得到另一个进程的消息时应等待，直到消息到达才被唤醒。     进程的互斥：指当有若干个进程都要使用某一共享资源时，任何时候最多只允许一个进程去使用该资源，其他要使用它的进程必须等待，直到该资源的占用者释放了该资源
共享内存实现父子进程间通讯
YJB666的专栏
06-04 1091
//共享内存实现父子进程间通讯 //2013-10-30 //yang #include<stdio.h> #include<stdlib.h> #include<string.h> #include<sys/ipc.h> #include<sys/shm.h> int main(void) { int shmid,pid=0,stop=...
Linux进程间通信
LG_DHS的博客
09-29 318
一、概念 进程间的通讯：是指在不同进程之间传播或交换信息，即A进程将“hello world”传递给B进程。 二、进程间的通讯方式 1、管道 管道实现的原理：通过在内存上开辟一块全新的空间。A、B进程都通过文件描述符操作这块空间，以完成数据交互的功能。 1.1、无名管道( pipe )：管道是一种半双工的通信方式，数据只能单向 流动，而且只能在具有父子进程间
进程间通信——消息队列
chenyijun的专栏
07-11 641
我们知道进程间通信采用管道时，a 进程给 b 进程传输数据，只能等待 b 进程取了数据之后 a 进程才能返回。所以管道不适合频繁通信的进程。那我们能不能把进程的数据放在某个内存之后就马上让进程返回呢？无需等待其他进程来取就返回呢？答是可以的，我们可以用消息队列的通信模式来解决这个问题，例如 a 进程要给 b 进程发送消息，只需要把消息放在对应的消息队列里就行了，b 进程需要的时候再去对应的消息队列里取出来。同理，b 进程要个 a 进程发送消息也是一样。这种通信方式也类似于缓存吧。
linux-linux进程间通信方式汇总.zip
最新发布
02-26
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程之间共享数据、交换信息的关键技术。本文将全面解析Linux中的各种进程间通信方式，帮助你深入理解这一核心概念。 首先，我们来了解...
linux-fusion-1.1.tar.gz_fusion_linux fusion_linux 进程 通信_linux-fu
09-20
描述中提到“linux进程间高级通信的一个模块”，这暗示了Linux Fusion可能是一个专注于进程间通信（IPC，Inter-Process Communication）的库或框架。在Linux系统中，进程间通信是不同进程之间交换数据的重要机制，...
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
Linux系统使用消息队列实现进程间通信
qq_44194231的博客
05-03 336
实现a进程和b进程间的通信，通过一个server进行中转，也可以不通过server直接互发消息，在本地需要创建一个save.txt文件（ftok的需要） //a进程 #include <stdio.h> #include <stdlib.h> #include <sys/msg.h> #include <string.h> struct msgbu...
8.6 A B进程消息队列互相通信+共享内存的读写
gqggg的博客
08-06 239
通信
十五、进程间通讯--消息队列
qq_43411555的博客
06-25 486
一、消息队列的概念 二、消息队列相关函数 三、实例
进程间通讯
123456789的博客
03-23 247
管道 有名管道：在磁盘上有一个文件标识，创建管道文件，但是，交互的数据并不会存储到磁盘中，管道文件不占磁盘空间。     创建管道文件：           命令：mkfifo filename        &nbsp...
C#使用共享内存实现进程间的通信
codeofcc的博客
09-26 8593
进程通信有多种方式，比如socket、管道、共享内存。c#直接提供了共享内存的相关库，但直接使用起来还是不太方便，需要使用Marshal处理内存对齐以及托管非托管转换的问题，本文提供一种，将上述操作包装，借助反射的手段，实现通过类和属性的方式使用共享内存。 一、.net共享内存对象 MemoryMappedFile是.net的共享内存对象，一般通过MemoryMappedFile.CreateNew的方式创建共享内存，最简单的创建方式是，传入名称及大小。 //申请共享内存 MemoryMapped
操作系统_进程同步与进程通信_用PV操作实现进程的同步
华工的专栏
07-12 5781
进程的同步是指并发进程之间存在一种制约关系， 一个进程的执行依赖另一个进程的消息， 当一个进程没有得到另一个进程的消息时应等待，直到消息到达才被唤醒。 PV操作与管程是两种典型的同步机制。 本文只介绍怎样用PV操作实现进程间的同步。 生产者 / 消费者问题 先看一个图： 把上图中的进程A “读一个记录并将其送入缓冲区” 看做“生产者生产了一件物品且把物品存入缓冲区”; 把进程B "从缓冲区取出记录并加工" 看做“消费者从缓冲区取出物品去消费”。 这样，上述问题涉及进程的同步就变成了生产者和消费...
进程管理之PV操作
SUGA_的博客
06-02 1449
llll
Linux系统编程——进程同步与互斥：System V 信号量
热门推荐
秋叶原 && Mike || 麦克
08-20 16万+
信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。 编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。 在实际应用中两个进程间通信可能会使用多个信号量，因此 System V 的信号量以集合的概念来管理，具体操作和 Posix 信号量大同小异，详情请点此链接：http://blog.csdn.net/te
牛牛的等差数列
青烟绕指柔的博客
04-18 1383
题目链接：牛牛的等差数列 对每个区间维护首项和公差即可。显然是具有可加性的。 最开始分块TLE了。 （比赛的时候L写成1了。。。。） AC代码： #pragma GCC optimize("-Ofast","-funroll-all-loops") #include<bits/stdc++.h> #define int long long #define mid (l+r>&...
Linux进程间通信—信号量
weixin_34242819的博客
11-17 143
二．信号量（semophore） 信号量是一种计数器，可以控制进程间多个线程或者多个进程对资源的同步访问，它常实现为一种锁机制。实质上，信号量是一个被保护的变量，并且只能通过初始化和两个标准的原子操作（P/V）来访问。（P，V操作也常称为wait(s),signal(s)） semaphore 与mutex类似，用于处理同步问题。我们说mutex像是一个只能容纳一个人的洗手间，那么semaph...
Linux进程间通信详解-PDF文档
文档可能详细解释了每种通信方法的原理、使用方法、优缺点以及示例代码，帮助读者深入理解Linux进程间通信的实现细节。此外，文档还可能涉及相关的系统调用和库函数，如`pipe()`, `fork()`, `open()`, `write()`, `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值