进程间通信

最新推荐文章于 2022-03-19 19:49:59 发布
最新推荐文章于 2022-03-19 19:49:59 发布
阅读量224 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_42720630/article/details/81842929
版权
这篇博客深入探讨了进程间通信的各种方式，包括有名管道（FIFO）和无名管道（PIPO），强调了它们在数据传输中的特点和应用场景。此外，还介绍了信号机制，如闹钟函数和kill函数，以及消息队列、共享内存和信号量等在多进程通信中的作用，这些机制为进程间的协调和数据交换提供了有效支持。

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

一、进程间通信方式

1、有名管道（FIFO）和管道（PIPO）。

管道：（1）单向，先进先出，把一个进程的输入和输出连接在一起。

           （2）在管道的尾部写入程序，在管道的头部读出数据。

           （3）数据被一个进程读取后，将从管道删除。

           （4）进程阻塞情况：读空管道时，或者进程已经写满。、

*（无名）管道：父进程和子进程之间的通信        int   pipe( int   fieldis[2] ) ;     数组保存两个文件描述符

           fieldis[0]  用于读管道      fieldis[1]  用于写管道

父进程写程序，子进程读程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.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("write");
		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;
}

必须在使用fork()函数之前调用pipe()创建管道，否则子进程不会继承父进程的文件描述符 

 

*有名管道：任意两个进程间的通信

写文件

#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"))  // buf内容为 bye 时结束
        {
	    break;
        }

        memset(buf, 0, sizeof(buf));  // 清空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));  // 清空buf
    }

    close(fd);

    unlink("fifo.tmp");               // 删除fifo.tmp文件
    return 0;
}

二、信号

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

void print(int num)  //num 信号的值
{
	printf("helloworld! %d \n", num);
}

int main()
{
    signal(9, SIG_IGN);  //当前进程收到信号2的时候，执行print函数（SIG_IGN表示2

    while (1);  // 保证进程不死
    return 0;
}

闹钟函数

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

void print(int num)
{
    alarm(1);
    printf("helloworld\n");
}

int main()
{
    alarm(1);                // 每秒钟发送一个SIGALRM（闹钟）信号，alarm函数生命周期只有一次
    signal(SIGALRM, print);  // 每接收到一个SIGALRM（闹钟）信号，就调用一次print函数

    while (1);

    return 0;
}

kil函数  ---- 发送给进程

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

int main()
{
	int id;

	scanf("%d", &id);
	kill(id, SIGKILL);  // 杀死进程号为id的进程

	return 0;	
}

raise函数  ---- 发送信号给本进程

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

int main()
{
	raise(2);    // 等价于  kill(getpid(),2);  终止本程序
	while (1);
	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));  // 清空buf
	
			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"))  // 输入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"))   // // 收到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); // 删除创建消息队列的信号量msgid

	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   // key值 （键值）

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);  // 杀死收到消息类型为2的进程（即子进程）
				break;
			}
			
			printf("\t\t\t%s\n", mbuf.mtext);   

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

	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, 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);  //删除创建共享内存的信号量semid
	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;
}

五、信号量

用于保护临界资源

｜@《@｜
关注
Vitis HLS 学习笔记--变量存储（通道的FIFO/PIPO选择）
hi94的博客
05-30 1254
本文通过调整 Vitis HLS 编译器的默认设置，选择FIFO或者PIPO作为通道缓存。PIPO 缓冲器可以自动调节，确保任务之间的重叠执行，而不会出现死锁。而显式手动串流的 FIFO 通道虽然可以更快地开始重叠执行，但需要小心调整队列大小，以避免死锁问题。
【嵌入式linux】进程间通信的几种方式
NBDR_YL的博客
05-06 965
管道： 无名管道PIPO 只能用于亲缘关系的进程间通信 半双工的通信模式。 有名管道 FIFO 可以用于互不相关的两个进程间通信 先进先出规则 信号 内核产生信号，用户注册信号处理函数，来进行信号事件的处理 共享内存 最高效的进程间通信方式，进程可以直接读写内存，不需要任何数据的拷贝 多进程通信过程中。内核分配有共同的内存区，需要访问的进程可以将其映射到自己的私有地址空间。 但是需要依靠互斥锁或者信号量来保证同步性。防止阻塞。 共享内存实现： （1）、创建共享内存 ...
Linux-----进程间通信
qq_56319128的博客
07-15 170
学习目标： 1、无名管道(pipo、fd[0]、fd[1]) 2、FIFO命名管道(mkfifo 阻塞状态 errno!=EEXIST) 学习内容： 进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。 IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。 进程间的五种通信方式介绍: https://blog.cs
Linux编程—系统编程（进程通信）
qq_52380197的博客
03-24 161
进程通信IPC InterProcess Communication 多个进程间的交互 方式： 1.管道（无名管道和命名管道）pipo FIFO 2.消息队列 3.共享内存 4.信号 5.信号量 6.还有Socket 、Streams用于不同主机间两个进程的通信 管道 1.无名管道：半双工，具有固定读写端。用于具有情缘关系的父子进程或兄弟进程。它可看作特殊文件，对其的读写使用系统调用的read/write,注意它不属于任何文件系统，只存在于内存中。 原型：int pipe(int pipefd[2]);成
进程间通信IPC之--无名管道（pipe）和有名管道（fifo）
嵌入式软硬件设计/方案设计
07-31 674
转载于：http://blog.chinaunix.net/uid-25365622-id-3059840.html 每个进程各自有不同的用户地址空间，任何一个进 程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲 区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterPro
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
UNIX Linux实验教程 4实验四Linux进程间通信.doc
09-26
UNIX/Linux 进程间通信实验教程 UNIX/Linux 操作系统提供了一组系统调用作为用户使用其进程间通信机制的接口。进程间通信是指在多任务计算机系统中，每个进程都具有自己独立的全局变量和局部变量，子进程几乎完全...
ipcs命令 多进程间通信常用的工具
01-09
ipcs命令是用于报告Linux中进程间通信设施的状态，显示的信息包括消息列表、共享内存和信号量的信息 。 语法格式：ipcs [参数] 常用参数： -a 默认的输出信息 -m 打印出使用共享内存进行进程间通信的信息 -q ...
linux中的pipe和fifo的区别
u012138828的专栏
08-05 2903
linux中的pipe和fifo的区别 在linux进程间通信(IPC)可以通过信号量、文件系统、消息队列、共享内存还有管道来实现的。其中消息队列、内存管理是在System V中提出的。 进程通信间涉及到了管道，而且管道在shell命令中也大有用处。那就简要说说管道： 管道顾名思义，你可以将其理解为日常生活中的管子，一边流入，一边流出。它可以有半双工和全双工。半双工就
pipe和FIFO
u011403897的专栏
07-28 1311
首先来看pipe： pipe用于具有相同祖先的进程（最简单的情况：父子进程）之间的通信。 在进程中调用pipe函数创建管道。这个管道是由内核创建并管理的。     #include     int pipe(intfiledes[2]); 该函数返回一个文件描述符数组fd[]，fd[0]用于读管道，fd[1]用于写管道。如下图： 与 FIFO" title="pipe 
Linux进程间的通信方式 管道 信号 消息队列 共享内存 信号量
海吹的技术博客
08-19 379
一、进程间通信概述 1.目的：数据传输、资源共享、通知事件、进程控制。 2.Linux使用的进程间通信方式包括： （1）管道（pipe）和有名管道（FIFO） （2）信号（signal） （3）消息队列 （4）共享内存 （5）信号量 （6）套接字（socket） 二、管道通信 1.特点：管道是单向的、先进先出的，一个进程在管道的尾部写入数据，另一个进程从管道的头部读出数据。数据...
【C/C++】【Linux】Linux系统调用——进程间通信
乞木的博客
08-19 7762
Linux系统调用——进程间通信 进程间通信概述 进程间通信（InterProcess Communication，IPC）是指在不同进程之间传播或交换信息。 Linux的进程间通信方法有管道(Pipe)和有名管道(FIFO)、信号(Signal)、消息队列(Message Queue)、共享内存(Shared Memory)、信号量(Semaphore)、套接字(Socket)等。 Li...
进程间的通信—管道pipe和fifo
风清扬
09-24 862
进程间的通信管道的学习笔记
管道 pipe是什么？（进程通信的一种方式）
Dontla的博客
11-27 4419
管道是一种进程间通信机制，好比一个管子，一边一个口，一个往里放，另一头可以往出取，操作是双向的 参考文章：什么是linux管道，windows下有管道类似的东西吗？ ...
四、Linux--管道
jfxu
12-03 271
1无名管道pipo() #include int pipe(int filedes[2]);   返回值：成功，返回0，否则返回-1。 参数数组包含pipe使用的两个文件的描述符。fd[0]:读管道，fd[1]:写管道。 功能：创建一个无名管道 必须在fork()前调用pipe()，否则子进程不会继承文件描述符。两个进程不共享祖先进程，就不能使用pipe。
进程间通信之管道pipe与fifo
qq_43460315的博客
03-19 1134
管道pipe()和fifo()的创建和使用
Linux学习笔记-命名管道（FIFO）
IT1995的博客
01-06 4992
目录   理论 例子 理论 在int mkfifo(const char *pathname, mode_t mode) 成功返回o，出错返回-1 他包含在头文件： #include &lt;sys/types.h&gt; #include &lt;sys/stat.h&gt;     这里要注意： 1.只要对FIFO有适当的访问权限，FIFO可用在任何两个没有任何关系的...
Linux进程间通信详解
"该资源为一份关于Linux进程间通信的PDF文档，由孙天泽于2006.3年撰写，主要介绍了Linux系统中的进程通信机制，适用于嵌入式Linux应用程序开发的学习与实践。文档内容包括Linux进程、内核开发、驱动程序开发以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值