进程间通信

最新推荐文章于 2024-03-05 15:24:41 发布
最新推荐文章于 2024-03-05 15:24:41 发布
阅读量168 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zoujiemax/article/details/85252798
版权

1、命名管道
(1)创建

int ret = mkfifo("/home/myfifo", 0766);
if (-1 == ret)
{
	perror("管道文件创建失败");
	return -1;
}

(2)写管道文件

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define SIZE 1024

int main()
{
	int fd = open("/home/myfifo", O_WRONLY);
	if (-1 == fd)
	{
		perror ("打开文件失败");
		return -1;
	}
	
	char buf[SIZE] = {0};
	while (1)
	{
		fgets(buf, SIZE, stdin);
		write(fd, buf, strlen(buf));
	}
	close (fd);
	return 0;
}

(3)读管道文件

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

#define SIZE 1024
int main()
{
	int fd = open("/home/myfifo", O_RDONLY);
	if (-1 == fd)
	{
		perror ("打开文件失败");
		return -1;
	}
	char buf[SIZE+1] = {0};
	while (1)
	{
		ssize_t ret = read(fd, buf, SIZE);
		if (-1 == ret)
		{
			perror("父进程读数据失败");
			break;
		}
		
		buf[ret] = '\0';
		printf ("读到数据：%s\n", buf);
		
	}
	close (fd);
	return 0;
}

(4)非阻塞读管道文件

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#define SIZE 1024
int main()
{
	int fd = open("/home/myfifo", O_RDONLY | O_NONBLOCK);
	if (-1 == fd)
	{
		perror ("打开文件失败");
		return -1;
	}
	char buf[SIZE+1] = {0};
	while (1)
	{
		ssize_t ret = read(fd, buf, SIZE);
		if (-1 == ret)
		{
			if (errno == EAGAIN)
			{
				printf("无数据可读\n");
				sleep(2);
				continue;
			}
			perror("父进程读数据失败");
			break;
		}
		
		buf[ret] = '\0';
		printf ("读到数据：%s\n", buf);
		
	}
	close (fd);
	return 0;
}

2、共享内存
(1)头文件

#ifndef _MSG_H_
#define _MSG_H_

typedef struct student
{
	char name[20];
	int id;
}Student;


#endif // _MSG_H_

(2)写入

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
#include "msg.h"
#include <string.h>
int main()
{
	// 1、创建或者获取操作共享内存的标识
	int shmid = shmget((key_t)1234, sizeof(Student), IPC_CREAT);
	if (-1 == shmid)
	{
		perror("共享内存创建失败");
		return -1;
	}
	
	// 2、将共享内存映射到本地，当做本地内存使用
	Student *ps = (Student*)shmat(shmid, NULL, 0);
	if (NULL == ps)
	{
		perror("共享内存映射失败");
		return -1;
	}
	
	strcpy(ps->name, "小明");
	ps->id = 10;
	
	// 3、解除映射
	shmdt(ps);

	
	// 4、删除共享内存
	shmctl(shmid, IPC_RMID, NULL);

	
	
	return 0;
}

(3)读取

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
#include "msg.h"
#include <string.h>
int main()
{
	// 1、创建或者获取操作共享内存的标识
	int shmid = shmget((key_t)1234, sizeof(Student), IPC_CREAT);
	if (-1 == shmid)
	{
		perror("共享内存创建失败");
		return -1;
	}
	
	// 2、将共享内存映射到本地，当做本地内存使用
	Student *ps = (Student*)shmat(shmid, NULL, 0);
	if (NULL == ps)
	{
		perror("共享内存映射失败");
		return -1;
	}
	
	printf ("name = %s, id = %d\n", ps->name, ps->id);
	
	// 3、解除映射
	shmdt(ps);
	
	// 4、删除共享内存
	
	return 0;
}

3、信号量
(1)头文件
ticket.h

#ifndef _TICKET_H_
#define _TICKET_H_

typedef struct shm
{
	int ticket;
}SHM;


#endif // _TICKET_H_

semaphore.h

#ifndef __SEMAPHORE_H__
#define __SEMAPHORE_H__
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <string.h>

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) */
};

// 信号量初始化
int init_smph(int semid)
{
	union semun sem;
	sem.val = 1;
	
	// 给信号量 semid进行初始化
	int ret = semctl(semid, 0, SETVAL, sem);
	if(ret == -1)
	{
		perror ("semctl");
		return -1;
	}
	
	return 0;
}

// 信号量的P操作
int semaphore_p(int semid)
{
	struct sembuf sem;
	memset (&sem, 0, sizeof(sem));
	
	sem.sem_num = 0;
	sem.sem_op  = -1;
	sem.sem_flg = SEM_UNDO;
	int ret = semop(semid, &sem, 1);
	if (ret == -1)
	{
		perror ("semop_p");
		return -1;
	}
	return 0;
}

// 信号量的v操作
int semaphore_v(int semid)
{
	struct sembuf sem;
	memset (&sem, 0, sizeof(sem));
	
	sem.sem_num = 0;
	sem.sem_op  = 1;
	sem.sem_flg = SEM_UNDO;
	int ret = semop(semid, &sem, 1);
	if (ret == -1)
	{
		perror ("semop_v");
		return -1;
	}
	return 0;
}

// 信号量的删除
int del_smph(int semid)
{	
	int ret = semctl(semid, 0, IPC_RMID);
	if(ret == -1)
	{
		perror ("semctl");
		return -1;
	}
	
	return 0;
}

#endif // __SEMAPHORE_H__

(3)main.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
#include "ticket.h"
#include "semaphore.h"
#include <time.h>

void sellticket(int semid, SHM *ps)
{
	srand((unsigned int)time(NULL));
	
	while (1)
	{
		usleep(100000*(rand()%10+1));
		
		semaphore_p(semid);          // p操作
	
		if (0 == ps->ticket)
		{
			printf ("票卖完了\n");
			semaphore_v(semid);      // v操作
			break;
		}
		printf ("卖了一张票，座位号：%d\n", ps->ticket);
		ps->ticket -= 1;
	
		semaphore_v(semid);          // v操作
	}
}


int main(int argc, char **argv)
{
	int shmid = shmget((key_t)456, sizeof(SHM), IPC_CREAT);    // 创建或者获取共享内存
	if (-1 == shmid)
	{
		perror("共享内存创建失败");
		return -1;
	}
  
	SHM *ps = (SHM*)shmat(shmid, NULL, 0);                     // 共享内存映射
	if (NULL == ps)
	{
		perror("共享内存映射失败");
		return -1;
	}
	                       
	int semid = semget((key_t)789, 1, IPC_CREAT);              // 创建信号量
	if (-1 == semid)
	{
		perror("信号量创建失败");
		return -1;
	}
	
	if (2 == argc)            // 初始化
	{
		ps->ticket = 100;
		init_smph(semid);  
	}
	
	
	
	sellticket(semid, ps);    // 卖票
	
	sleep(2);
	if (2 == argc)
	{
		del_smph(semid);
		shmctl(shmid, IPC_RMID, NULL);
	}
	
	return 0;
}

4、信号
(1)信号捕捉

#include <stdio.h>
#include <signal.h>

void handle_signal(int sigNum)
{
	if (sigNum == 2)
		printf ("捕获到  Ctrl + c\n");
	else if (sigNum == 15)
		printf ("捕获到  kill 信号\n");
}

int main()
{	
	signal(SIGINT, handle_signal);    // Ctrl + c
	signal(SIGTERM, handle_signal);   // Ctrl + c
	while (1)
	{
		printf ("a\n");
		sleep(2);
	}

	return 0;
}

(2)定时器

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

void handle_signal(int sigNum)
{
	if (sigNum == SIGALRM)
	{
		printf ("hello\n");
		alarm(2);      // 重置定时时间
	}
}

int main()
{	
	signal(SIGALRM, handle_signal);    // 定时信号
	alarm(2);          // 定时5秒
	
	while (1);

	return 0;
}

(3)处理子进程退出

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

void handle_signal(int sigNum)
{
	pid_t pid;

	while ((pid = waitpid(-1, NULL, WNOHANG)) > 0)
	{
		printf ("处理了一个子进程退出信息，子进程的id = %d\n", pid);
	}
}

int main()
{	
	signal(SIGCHLD, handle_signal);    // 定时信号
	
	
	int i;
	for (i = 0; i < 10; i++)
	{
		pid_t pid = fork();
		if (0 == pid)
			break;
	}
	
	while (1);
	
	


	return 0;
}
zoujiemax
关注
Linux网络编程之利用信号量防止僵尸子进程
weixin_44027897的博客
06-16 248
1. 问题由来？ TCP server 端通过为每一个新来的连接创建新的子进程，从而达到支持 multi connection的目的，在某个连接close 掉的时候，就意味着 相应的子进程 退出，这时候就需要在父进程中做一些善后处理，防止产生僵尸进程。 2. 僵尸进程是如何产生的？ 当一个子进程退出后，并不是立即释放所以的资源，而是通知父进程，由父进程继续后续工作，子进程通知父进程通过产生信号（S...
IOS程序crash捕获
静水流深
11-18 2597
IOS程序crash捕获 基础理论 Crash分为两种，一种是程序抛出的异常，没有被捕获造成的；另一种是signal类型的异常。针对未被捕获的异常可以使用NSSetUncaughtExceptionHandler系统方法来设置异常处理函数；对于signal类型的异常，需要使用signal系统方法给每种需要处理的signal类型的异常设置处理函数。如果没有为一个信号设置对应的处理函数，就会使用默
Socket 编程时候遇到的Broken pipe问题
不完美星空
04-02 7138
   昨天有个程序除了问题，调试的时候发现是在SOCKET通信的时候对方关闭连接的情况下出现brokenpipe错误。在网上搜索了一番，别人解释原因是向已经关闭连接的SOCKET管道写入数据造成的，但是我的程序只是在对方关闭的时候继续RECV，难道RECV也会向管道写入数据，这个问题以后再研究吧。    知道了问题就好办了。UNIX的系统是采用信号机制向进程通知这种系统错误的，13
进程间通信详解
向未来❀去探索 的博客
06-26 1万+
进程间通信详解(命名管道，匿名管道，共享内存)
进程间通信之共享内存
k5426244的博客
07-19 2206
1.进程间通信的分类：（1）管道：1、匿名管道pipe;2、命名管道mkfifo（2）System V IPC：1、System V 消息队列;2、System V 共享内存;3、System V 信号量。（3）POSIX IPC：1、消息队列;2、共享内存;3、信号量;4、互斥量;5、条件变量;6、读写锁。前面已经了解了进程间管道通信，那么共享内存又是什么原理？
【Linux】进程间通信
热门推荐
Edward_Asia的博客
05-02 1万+
目录 1. 进程间通信 1.1. 进程间通信的目的 1.2. 如何实现进程间通信 2. 管道通信 2.1. 匿名管道 2.1.1 创建匿名管道 2.1.2 . 深入理解匿名管道 2.2. 命名管道 2.2.1. 创建命名管道 3. system V 标准进程间通信 3.1. 共享内存 3.1.1. 实现原理 3.1.2. 代码实现 3.2. 消息队列(了解) 3.2.1 实现原理 3.3. 信号量(了解) 3.3.1. 实现原理 1. 进程间通信 1.1.
android 进程间通信
anhuilee的博客
03-05 1942
管道是单向的，管道一端连接着进程的输出，进程把数据放入管道，另一端连接进程的输入，进程从管道获取数据。实现数据通信。信号类似于通知，进程通过sigaction注册接收的信号，执行响应函数。信号量类似一个计数器，用来控制多个进程对共享资源的访问， 会有一个>0的初始值，每当有进程申请使用信号量，信号量就会-1，当减到0的时候，其他进程想要访问，就必须等待，当进程执行完工作后，会释放信号量，进行+1操作。共享内存是一段物理内存，可以供给不同的进程访问。
Linux-进程间通信
AI_ELF的博客
08-23 6976
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
C++进程间通信 详解2
GIS摆渡人
05-24 3633
文章目录 一、概述二、进程间通信概念及方法1. 管道的概念2. pipe3. 管道的读写行为4. 管道缓冲区大小5. 管道优劣6. FIFO7. 共享存储映射8. mmap函数9. munmap函数10. mmap九问11. mmap父子进程间通信12. 匿名映射13. mmap无血缘关系进程间通信 3. 练习 一、概述 二、进程间通信概念及方法 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和...
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
C#使用SendMessage实现进程间通信的方法
09-03
在C#编程中，进程间通信（IPC，Inter-Process Communication）是一种允许不同进程之间交换数据的技术。在本文中，我们将探讨如何使用Windows API中的`SendMessage`函数在两个C#进程中实现这一通信方式。 `...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
UNIX Linux实验教程 4实验四Linux进程间通信.doc
09-26
UNIX/Linux 进程间通信实验教程 UNIX/Linux 操作系统提供了一组系统调用作为用户使用其进程间通信机制的接口。进程间通信是指在多任务计算机系统中，每个进程都具有自己独立的全局变量和局部变量，子进程几乎完全...
python小爬虫.zip
11-12
python小爬虫
最全的JAVA设计模式，包含原理图解+代码实现.zip
最新发布
11-12
最全的JAVA设计模式，包含原理图解+代码实现
CPPC++_世界上最快的3d贴图转换工具.zip
11-12
CPPC++_世界上最快的3d贴图转换工具
【风电】基于TCN-BiGRU的风电功率单变量输入多步预测研究附Matlab代码.rar
11-12
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Linux进程间通信详解
"该资源为一份关于Linux进程间通信的PDF文档，由孙天泽于2006.3年撰写，主要介绍了Linux系统中的进程通信机制，适用于嵌入式Linux应用程序开发的学习与实践。文档内容包括Linux进程、内核开发、驱动程序开发以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值