Linux进程间通信

最新推荐文章于 2023-03-05 12:13:35 发布
原创 最新推荐文章于 2023-03-05 12:13:35 发布 · 195 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入讲解了进程间通信(IPC)的多种方式，包括管道通信（无名管道和有名管道）、共享内存、消息队列及信号量等。通过具体代码示例展示了每种通信方式的应用场景和技术细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一 、管道通信

1 、无名管道

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

void ReadData(int fd)
{
	int ret;
	char buf[32] = {0};

	while (1)
	{
		ret = read(fd, buf, sizeof(buf));
		if (-1 == ret)
		{
			perror("read");
			exit(1);
		}

		if (!strcmp(buf, "bye"))
		{
			break;
		}

		printf("read from pipe : %s\n", buf);

		memset(buf, 0, sizeof(buf));
	}

	close(fd);
}

void WriteData(int fd)
{
	int ret;
	char buf[32] = {0};

	while (1)
	{
		scanf("%s", buf);

		ret = write(fd, buf, strlen(buf));
		if (-1 == ret)
		{
			perror("wirte");
			exit(1);
		}

		if (!strcmp(buf, "bye"))
		{
			break;
		}

		memset(buf, 0, sizeof(buf));
	}

	close(fd);
}

int main()
{
	int ret, fd[2] = {0};
	pid_t pid;

	ret = pipe(fd);   //创建一个无名管道
	if (-1 == ret)
	{
		perror("pipe");
		exit(1);
	}

	pid = fork();    
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)
	{
		close(fd[1]);       //关闭写端口
		ReadData(fd[0]);    //fd[0]读数据
	}
	else
	{
		close(fd[0]);       //关闭读端口
		int status;
		WriteData(fd[1]);   //fd[1]写数据

		wait(&status);
	}

	return 0;
}

2 、有名管道

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

int main()
{
	int ret, fd;
	char buf[32] = {0};    //管道写数据

	fd = open("fifo.tmp", O_WRONLY);
	if (-1 == fd)
	{
		perror("open");
		exit(1);
	}

	while (1)
	{
		scanf("%s", buf);
		ret = write(fd, buf, strlen(buf));
		if (-1 == ret)
		{
			perror("read");
			exit(1);
		}

		if (!strcmp(buf, "bye"))
		{
			break;
		}

		memset(buf, 0, sizeof(buf));
	}

	close(fd);

	return 0;
}

 

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

int main()
{
	int ret, fd;
	char buf[32] = {0};    //从管道读取数据

	ret = mkfifo("fifo.tmp", 666);  //创建有名管道
	if (ret == -1)
	{
		perror("mkfifo");
		exit(1);
	}

	fd = open("fifo.tmp", O_RDONLY);
	if (-1 == fd)
	{
		perror("open");
		exit(1);
	}

	while (1)
	{
		ret = read(fd, buf, sizeof(buf));
		if (-1 == ret)
		{
			perror("read");
			exit(1);
		}

		if (!strcmp(buf, "bye"))
		{
			break;
		}

		printf("%s\n", buf);

		memset(buf, 0, sizeof(buf));
	}

	close(fd);

	unlink("fifo.tmp");

	return 0;
}

 

二 、共享内存

1、申请共享内存   shmget

2、映射                  shmat

3、使用                  strcpy

4、解除映射           shmdt

5、销毁共享内存    shmctl

 

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

#define SHMKEY   1234
#define SHMSIZE  4096       //以页为单位分配共享内存
#define SEMKEY   1234

union semun {
	int              val;    /* Value for SETVAL */
	struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
	unsigned short  *array;  /* Array for GETALL, SETALL */
	struct seminfo  *__buf;  /* Buffer for IPC_INFO(Linux specific) */
};

void sem_p(int semid)
{
	int ret;
	struct sembuf sbuf;

	sbuf.sem_num = 0;      //第一个 从0开始
	sbuf.sem_op = -1;      //p操作
	sbuf.sem_flg = SEM_UNDO;  

	ret = semop(semid, &sbuf, 1);
	if (-1 == ret)
	{
		perror("semop");
		return;
	}
}

void sem_v(int semid)
{
	int ret;
	struct sembuf sbuf;

	sbuf.sem_num = 0;      //第一个 从0开始
	sbuf.sem_op = 1;      //v操作
	sbuf.sem_flg = SEM_UNDO;  

	ret = semop(semid, &sbuf, 1);
	if (-1 == ret)
	{
		perror("semop");
		return;
	}
}

int main()
{
	int shmid, semid, ret;
	void *shmaddr;
	int count = 0;

	shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);   //创建共享内存
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}

	semid = semget(SEMKEY, 1, IPC_CREAT | IPC_EXCL);    //创建信号量
	if (semid == -1)
	{
		perror("semget");
		exit(1);
	}

	union semun unsem;
	unsem.val = 1;    //初始化成二值信号量
	ret = semctl(semid, 0, SETVAL, unsem);    //初始化信号量
	if (-1 == ret)
	{
		perror("semctl");
		exit(1);
	}

	shmaddr = shmat(shmid, NULL, 0);    //映射到虚拟地址空间
	if (NULL == shmaddr)
	{
		perror("shmat");
		exit(1);
	}

	*(int *)shmaddr = count;       //数据写到共享内存

	while (1)
	{
		sem_p(semid);             //p操作  拔钥匙
		count = *(int *)shmaddr;     //读取数据
		usleep(100000);
		if (count >= 100)
		{
			break;
		}

		printf("Process A : count = %d\n", count);

		count++;

		*(int *)shmaddr = count;    //写回共享内存
		sem_v(semid);           //v操作  加一操作  插钥匙
	}

	shmdt(shmaddr);               //解除映射
	shmctl(shmid, IPC_RMID, NULL);

	semctl(semid, 0, IPC_RMID);
	return 0;
}

 

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

#define SHMKEY   1234
#define SHMSIZE  4096       //以页为单位分配共享内存
#define SEMKEY   1234

union semun {
	int              val;    /* Value for SETVAL */
	struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
	unsigned short  *array;  /* Array for GETALL, SETALL */
	struct seminfo  *__buf;  /* Buffer for IPC_INFO(Linux specific) */
};

void sem_p(int semid)
{
	int ret;
	struct sembuf sbuf;

	sbuf.sem_num = 0;      //第一个 从0开始
	sbuf.sem_op = -1;      //p操作
	sbuf.sem_flg = SEM_UNDO;  

	ret = semop(semid, &sbuf, 1);
	if (-1 == ret)
	{
		perror("semop");
		return;
	}
}

void sem_v(int semid)
{
	int ret;
	struct sembuf sbuf;

	sbuf.sem_num = 0;      //第一个 从0开始
	sbuf.sem_op = 1;      //v操作
	sbuf.sem_flg = SEM_UNDO;  

	ret = semop(semid, &sbuf, 1);
	if (-1 == ret)
	{
		perror("semop");
		return;
	}
}

int main()
{
	int shmid, semid, ret;
	void *shmaddr;
	int count = 0;

	shmid = shmget(SHMKEY, SHMSIZE, 0);   //创建共享内存
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}

	semid = semget(SEMKEY, 1, 0);    //创建信号量
	if (semid == -1)
	{
		perror("semget");
		exit(1);
	}

	shmaddr = shmat(shmid, NULL, 0);    //映射到虚拟地址空间
	if (NULL == shmaddr)
	{
		perror("shmat");
		exit(1);
	}

	while (1)
	{
		sem_p(semid);             //p操作  拔钥匙
		count = *(int *)shmaddr;     //读取数据
		usleep(100000);
		if (count >= 100)
		{
			break;
		}

		printf("Process B : count = %d\n", count);

		count++;

		*(int *)shmaddr = count;    //写回共享内存
		sem_v(semid);           //v操作  加一操作  插钥匙
	}

	shmdt(shmaddr);               //解除映射
	return 0;
}

 

三 、消息队列

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

#define MSGKEY   1234

struct msgbuf {
	long mtype;     /* message type, must be > 0 */
	char mtext[64];  /* message data */
};

int main()
{
	struct msgbuf mbuf;
	int ret;

	int msgid = msgget(MSGKEY, IPC_CREAT | IPC_EXCL);
	if (-1 == msgid)
	{
		perror("msgget");
		exit(1);
	}

	pid_t pid = fork();
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)    //子进程发送
	{
		while (1)
		{
			memset(&mbuf, 0, sizeof(mbuf));            //清零操作
	
			mbuf.mtype = 1;   //消息类型
			scanf("%s", mbuf.mtext);

			ret = msgsnd(msgid, &mbuf, sizeof(mbuf.mtext), 0);
			if (-1 == ret)
			{
				perror("msgsnd");
				exit(1);
			}

			if (!strcmp(mbuf.mtext, "bye"))
			{
				mbuf.mtype = 2;
				msgsnd(msgid, &mbuf, sizeof(mbuf.mtext), 0);
				break;
			}
		}
	}
	else                 //父进程接收
	{
		while (1)
		{
			memset(&mbuf, 0, sizeof(mbuf));
		
			ret = msgrcv(msgid, &mbuf, sizeof(mbuf.mtext), 2, 0);
			if (-1 == ret)
			{
				perror("msgrcv");
				exit(1); 
				
			}

			if (!strcmp(mbuf.mtext, "bye"))
			{	
				kill(pid, 2);
				break;
			}
			
			printf("\t\t\t%s\n", mbuf.mtext);

			memset(&mbuf, 0, sizeof(mbuf));
		}
	}

	sleep(1);
	msgctl(msgid, IPC_RMID, NULL);

	return 0;
}

 

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

#define MSGKEY   1234

struct msgbuf {
	long mtype;     /* message type, must be > 0 */
	char mtext[64];  /* message data */
};

int main()
{
	struct msgbuf mbuf;
	int ret;

	int msgid = msgget(MSGKEY, 0);
	if (-1 == msgid)
	{
		perror("msgget");
		exit(1);
	}

	pid_t pid = fork();
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)    //子进程发送
	{
		while (1)
		{
			memset(&mbuf, 0, sizeof(mbuf));
	
			mbuf.mtype = 2;   //消息类型
			scanf("%s", mbuf.mtext);

			ret = msgsnd(msgid, &mbuf, sizeof(mbuf.mtext), 0);
			if (-1 == ret)
			{
				perror("msgsnd");
				exit(1);
			}

			if (!strcmp(mbuf.mtext, "bye"))
			{
				mbuf.mtype = 1;
				msgsnd(msgid, &mbuf, sizeof(mbuf.mtext), 0);
				break;
			}
		}
	}
	else                 //父进程接收
	{
		while (1)
		{
			memset(&mbuf, 0, sizeof(mbuf));
		
			ret = msgrcv(msgid, &mbuf, sizeof(mbuf.mtext), 1, 0);
			if (-1 == ret)
			{
				perror("msgrcv");
				exit(1);
			}

			if (!strcmp(mbuf.mtext, "bye"))
			{
				kill(pid, 2);
				break;
			}
			
			printf("\t\t\t%s\n", mbuf.mtext);

			memset(&mbuf, 0, sizeof(mbuf));
		}
	}

	return 0;
}

四 、信号量

  信号量(又名：信号灯)与其他进程间通信方式不大相同，主要用途是保护临界资源. 进程可以根据它判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步。

  二值信号灯：信号灯的值只能取0或1，类似于互斥锁。 但两者有不同： 信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值； 互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。     计数信号灯：信号灯的值可以取任意非负值

 

系统IO实现文件拷贝时无法复制二进制文件问题
Little Big Us的博客
09-16 266
使用LINUX系统IO实现文件拷贝时无法拷贝二进制文件以及解决
Linux进程间通信方式之socket使用实例
09-15
### Linux进程间通信方式之socket使用实例详解 #### 一、引言 在现代操作系统中，进程间的通信（IPC）是实现多进程协同工作的重要手段之一。Linux提供了多种进程间通信的方法，包括信号量、消息队列、共享内存以及...
Linxu下的串口编程
zd394071264的专栏
01-17 957
Linxu下的串口编程（二） --------------------------------------------------------- Author             :tiger-john WebSite            :blog.csdn.net/tigerjb Email               ：jibo.tiger@gmail.com Upd
Linux系统编程--read/write
liaoyoujinb的专栏
10-24 1019
Linux系统编程--read/write   2012-07-06 16:44:10|  分类： Linux |字号 订阅 来自：http://blog.163.com/bowen_tong/blog/static/20681717420126601118551/ 解决疑惑：读写普通文件不会阻塞，但对于网络及终端可能阻塞。 4. read/write  r
再探Linux内核write系统调用操作的原子性
热门推荐
TCP/IP
12-23 2万+
很多人都在问Linux系统的write调用到底是不是原子的。网上能搜出一大堆文章，基本上要么是翻译一些文献，要么就是胡扯，本文中我来结合实例来试着做一个稍微好一点的回答。  先摆出结论吧。结论包含两点，即write调用不能保证什么以及write调用能保证什么。  首先，write调用不能保证你要求的调用是原子的，以下面的调用为例：ret = write(fd, buff, 512);Linux无法保
Linux-应用编程-学习笔记（16）：文件IO
qq_42826337的博客
04-30 2286
Linux-应用编程-学习笔记（16）：文件IO 前言：基于LINUX做应用编程，其实就是通过调用LINUX的系统API来实现需要完成的任务。通过LINUX对文件进行操作的API称为文件IO（input和output），也就是读写文件。 一、文件操作的主要API接口 API是一些函数，这些函数是由linux系统提供支持的，由应用层程序来使用。应用层程序通过调用API来调用操作系统中的各种功能，来干...
UNIX Linux实验教程 4实验四Linux进程间通信.doc
09-26
UNIX/Linux 进程间通信实验教程 UNIX/Linux 操作系统提供了一组系统调用作为用户使用其进程间通信机制的接口。进程间通信是指在多任务计算机系统中，每个进程都具有自己独立的全局变量和局部变量，子进程几乎完全...
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
open函数，close函数，write函数，read函数，lseek函数
sakura0908的博客
03-05 452
SEEK_END（文件尾）:The offset is set to the size of the file plus offset bytes.O_TRUNC:如果文件存在并且是一个普通文件，而且打开方式是O_WRONLY|O_TRUNC,O_APPEND:以追加的方式打开文件，在每一次写之前，文件的定位在末尾。4、如果删除了某一个文件描述符的值，下次打开文件优先重复利用被删除的值。说明：1、使用带mode参数的read的时候，如果需要检验设置的权限，需要到家目录里执行。
write（）与 read() 函数用法（C语言）
Wzwzzz__的博客
11-04 1万+
因为写完文件以后文件流指针会指向文件末尾，这时再读取文件就会失败，使用上面的方法就避免了这种情况哦。注意：在写完文件以后读取文件之前，要先关闭文件再重新打开文件，否则会出现错误。count: 读取字节数的大小，不能超过buf的大小。buf: 定义的缓冲区，是一个指针，指向一段内存。返回值：成功返回写入文件的字节数，失败返回-1。返回值：成功返回实际读取的字节数，失败返回-1。fd: 文件描述符，读到文件末尾返回0。count: 写入文件的字节数。：将数据写入已经打开的文件内。读取指定文件中的文件内容。
Python文件读写与csv
网络架构
07-20 534
Python文件读写与csv21 文件操作21.1 文件的基本操作21.2 读文件21.3 读写位置定位21.4 写文件21.5 csv文件读写 21 文件操作 Python在一些应用应用例如：机器学习、大数据、深度学习等延伸领域或多或少地或用到一些样例文件，有的是纯文本的有的是用一定的符号例如逗号、分号、冒号等将一条记录的各个字段分割开，这样的存储数据的方式典型的文件类型有csv文件、xml文件等。 21.1 文件的基本操作 Python编程文件读写和其他语言下的文件读写过程和使用的函数基于一样，一般流程
Linux C/C语言 文件编程
海吹的技术博客
08-13 452
一、Linux 文件 Linux文件可分为：普通文件，目录文件，链接文件，设备文件； 当打开一个现存文件或创建一个新文件时，内核就向进程返回一个文件描述符；当需要读写文件时，也需要把文件描述符作为参数传递给相应的函数。 二、Linux文件操作函数（文件I/O） 1. open（）打开 函数是用于打开或创建文件，在打开或创建文件时可以指定文件的属性及用户的权限等各种参数。 #includ...
UNIX/Linux --进程间通信
李政的博客
07-26 314
一、基本概念     进程间通信（IPC）：进程之间交换数据的过程叫进程间通信。     进程间通信的方式：         简单的进程间通信：               命令行：父进程通过exec函数创建子进程时可以附加一些数据。             环境变量：父进程通过exec函数创建子进程顺便传递一张环境变量表。             信号：父子进程之间可以根据进程号相互...
进程间通信
qq_42232643的博客
08-18 161
1.什么是进程间通信？        进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着什么双方都可以访问的介质呢?进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。但是，系统空间却是"公共场所"，所以内核显然可以提供这样的条件。除此以外，那就是双方都可以访问的外设了。在这个意义上，两个进程当然也可以通过磁盘上的普通文件交换信息，或者通过"注册表"或其...
SIEMENS西门子 1200 PLC 轴运动控制程序模板：包含多项目成熟应用的程序块与电路图
08-13
内容概要：本文介绍了西门子1200 PLC轴运动控制程序模板的具体应用，特别是为海康威视制作的一台装路由器壳子的机器。该程序涵盖了轴控制（3个伺服和1个电缸）、PUT GET块与上下游PLC通讯、气缸报警处理等功能，并附有完整的电路图和威纶通触摸屏程序。程序块已在多个项目中成功应用，具有很高的复用性和实用性。文中详细解释了各个功能模块的工作原理及其在实际项目中的应用价值。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是那些需要深入了解西门子1200 PLC轴运动控制的人群。 使用场景及目标：① 学习如何利用西门子1200 PLC进行轴控制、电缸控制以及与上下游PLC的通讯；② 掌握气缸报警处理机制，提升系统的安全性和可靠性；③ 利用提供的完整电路图和触摸屏程序，快速搭建和调试控制系统。 其他说明：该程序模板不仅有助于提高开发效率，还能帮助初学者更好地理解和掌握西门子1200 PLC的相关技术和最佳实践。
电子工程领域Simulink下BUCK电路PI闭环控制仿真与分析
最新发布
08-13
BUCK电路（一种降压型DC-DC转换器）的基本原理及其在Simulink环境下的仿真方法。重点探讨了采用PI闭环控制方式对BUCK电路进行仿真的过程，包括设置输入输出电压、开关频率等参数，以及观察关键节点波形的变化。文中还提供了简单的Matlab代码片段用于创建BUCK电路模型和设置PI控制器参数，帮助读者理解和掌握整个仿真流程。此外，文章强调了通过调整电感、电容等元件参数来优化电路性能的方法。 适合人群：电子工程领域的学生、研究人员和技术爱好者，尤其是那些希望深入了解BUCK电路工作原理及仿真技巧的人群。 使用场景及目标：适用于想要通过理论结合实践的方式学习BUCK电路的设计与优化，旨在提高电路设计能力，确保输出电压稳定可靠。 其他说明：文中提供的代码仅为示例，在实际应用中可能需要根据具体情况做出相应修改。同时，建议读者在学习过程中多做实验，不断尝试不同的参数组合以加深理解。
Linux进程间通信详解
"该资源为一份关于Linux进程间通信的PDF文档，由孙天泽于2006.3年撰写，主要介绍了Linux系统中的进程通信机制，适用于嵌入式Linux应用程序开发的学习与实践。文档内容包括Linux进程、内核开发、驱动程序开发以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值