进程间通信（B站自学篇）

最新推荐文章于 2022-08-06 12:49:22 发布
最新推荐文章于 2022-08-06 12:49:22 发布
阅读量339 收藏
点赞数
分类专栏： 大并发实训 文章标签： linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46338854/article/details/122293900
版权
本文深入探讨了进程间通信的各种方法，包括无名管道的创建和使用，有名管道（FIFO）的创建与管理，信号的发送、接收及处理，共享内存的创建、映射、读写及删除，以及消息队列的创建、读写和删除。这些技术在多进程协同工作时起到关键作用，详细阐述了它们的工作原理和应用场景。
摘要由CSDN通过智能技术生成

无名管道

对同一个管道进行操作

内核管道由队列实现—特殊的文件
open 只能创建普通文件
用pipe函数来创建文件
返回值 （文件描述符）open（文件名称，打开模式，权限）
int返回值（==0成功，=-1失败）pipe(文件描述符【2个】–fd[2])
read文件描述符fd[0],write文件描述符fd[1]

注意：
（1）管道是创建在内存中的，进程结束，空间释放，管道就不存在了
（2）管道中的东西，读完了就删了
（3） 如果管道中没有东西可读，则会阻塞

写阻塞，读阻塞
缺点：
不能实现非亲缘关系（非父子进程）之间的通信

pipe1.c

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
int main()
{
    int fd[2];
    int ret;
    ret=pipe(fd);

    char writebuf[]="hello world!";
    char readbuf[128]={0};
    if(ret<0)
    {
        perror("create pipe error!");
        exit(1);
    }
    printf("create pipe success fd[0]=%d,fd[1]=%d\n",fd[0],fd[1]);

    write(fd[1],writebuf,sizeof(writebuf));

    read(fd[0],readbuf,128);

    printf("readbuf=%s\n",readbuf);

    memset(readbuf,0,128);
    //second read from pipe
    read(fd[0],readbuf,128);
    printf("second read after\n");
    
    close(fd[0]);
    close(fd[1]);
    return 0;
}

在这里插入图片描述

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
int main()
{
    int i=0;
    int fd[2];
    int ret;
    ret=pipe(fd);

    char writebuf[]="hello world!";
    char readbuf[128]={0};
    if(ret<0)
    {
        perror("create pipe error!");
        exit(1);
    }
    printf("create pipe success fd[0]=%d,fd[1]=%d\n",fd[0],fd[1]);

    while(i<100000)
    {    
         write(fd[1],writebuf,sizeof(writebuf));
	 i++;
    }
    printf("write pipe end\n");


    
    close(fd[0]);
    close(fd[1]);
    return 0;
}

在这里插入图片描述

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

int main()
{
	pid_t pid;
	int fd[2];
	int ret;
	char process_inter=0;
	ret =pipe(fd);
	if(ret<0)
	{
		perror("create pipe error!");
		exit(1);
	}
	printf("create pipe success!\n");

	pid =fork();
	if(pid==0)
	{
		int i=0;
		read(fd[0],&process_inter,1);
		while(process_inter==0);
		for(i=0;i<5;i++)
		{
			printf("this is child process i=%d\n",i);
			usleep(100);
		}
	}
	if(pid>0)//parent process
	{
		int i=0;
		for(i=0;i<5;i++)
		{
			printf("this is parent process i=%d\n",i);
			usleep(100);
		}
		process_inter=1;
		sleep(5);
		write(fd[1],&process_inter,1);

	}
}

在这里插入图片描述

有名管道

文件系统中存在一个文件节点
文件类型：管道文件
mkfifo：创建管道文件
返回值int（=0成功，<0失败）mkfifo（文件名，权限） 和umask 有关
并没有在内核中创建管道，是通过open函数打开时在内核中生成管道

有名管道、字符设备、块设备、套接字 只有文件节点，不占磁盘空间

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<fcntl.h>
#include<sys/stat.h>
int main()
{
	int ret;
	ret=mkfifo("./mkfifo.txt",0777);
	if(ret<0)
	{
		perror("create mkfifo error!");
		exit(1);
	}
	printf("create mkfifo success!\n");
	return 0;
}

在这里插入图片描述

firstmkfifo.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int main()
{
	int fd;
	char process_inter=0;
	fd=open("./mkfifo.txt",O_WRONLY);
	if(fd<0)
	{
		perror("open file error!");
		exit(1);
	}
	printf("open file success!\n");

	for(int i=0;i<5;i++)
	{
		printf("this is first process i=%d\n",i);
		usleep(100);
	}
	process_inter=1;
	sleep(3);
	write(fd,&process_inter,1);
	while(1);

	return 0;
}

secondmkfifo.c

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

int main()
{
	int fd;
	char process_inter=0;
	fd=open("./mkfifo.txt",O_RDONLY);
	if(fd<0)
	{
		perror("open file error!");
		exit(1);
	}
	printf("open file success!\n");

	read(fd,&process_inter,1);
	while(process_inter==0);

	for(int i=0;i<5;i++)
	{
		printf("this is second process i=%d\n",i);
		usleep(100);
	}
	while(1);

	return 0;
}

在这里插入图片描述

信号通信

信号的对象在内核中已经存在
内核中有很多信号
通过kill -l 查看有多少种信号

1）信号发送 kill（可以发送给任意进程） raise (只能向当前进程发送信号) alarm(只能发一种信号：闹钟信号SIGALRM,定时一段时间才发信号，只能发送给当前进程)
2）信号接收pause（） sleep while（1）
3）信号处理signal

int（=0成功，=-1失败） kill（进程号，信号）
例：kill （1111,9）//要转换

int raise(信号)

unsigned int alarm(unsigned int seconds：指定秒数)

int(==0成功) pause(void);使之睡眠，相当于sleep，但这个可以一直睡眠

void（*signal（int signum,void(*handler）(int))）(int);

A=void(*handler）(int)):函数指针变量，函数的形式：含有一个整型参数，无返回值的函数

void（*signal（int signum,A(int);有两个参数
第一个参数：信号值：处理哪个信号
第二个参数：函数指针：怎样处理这个信号
三种形式：SIG_ING:忽略该信号
SIG_DFL:采用系统默认方式处理信号
自定义的信号处理函数指针
返回值：函数指针

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

int main(int argc,char*argv[])
{
	int sig;
	int pid;
	if(argc<3)
	{
		printf("please input param\n");
		return -1;
	}

	sig=atoi(argv[1]);
	pid=atoi(argv[2]);
	printf("sid=%d,pid=%d\n",sig,pid);
	
	kill(pid,sig);
	return 0;
}

在这里插入图片描述


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

int main()
{
	printf("raise before\n");
	raise(9);//_exit()
	printf("raise after\n");
	return 0;
}

在这里插入图片描述

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

int main()
{
	pid_t pid;
	pid=fork();
	if(pid>0)
	{
		sleep(8);
		if(waitpid(pid,NULL,WNOHANG)==0)
		{
			kill(pid,9);
		}
		wait(NULL);
		while(1);

	}
	if(pid==0)
	{
		printf("raise function before \n");
		raise(SIGTSTP);
		printf("raise function after\n");
		exit(0);
	}

	return 0;
}

在这里插入图片描述


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

int main()
{
	int i=0;
	printf("alarm before\n");
	alarm(9);
	printf("alarm after\n");

	while(i<20)
	{
		i++;
		sleep(1);
		printf("process things,i=%d!\n",i);
	}

	return 0;
}

在这里插入图片描述


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

int main()
{
	int i=0;
	printf("pause before\n");
	pause();
	printf("pause after\n");

	while(i<20)
	{
		i++;
		sleep(1);
		printf("process things,i=%d!\n",i);
	}

	return 0;
}

在这里插入图片描述


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

void myfun(int signum)
{
	int i=0;
	while(i<10)
	{
		printf("process signal  signum=%d\n",signum);
		sleep(1);
		i++;
	}
	return ;
}
int main()
{
	int i=0;
	
	signal(14,myfun);
	printf("alarm before\n");
	alarm(9);
	printf("alarm after\n");

	while(i<20)
	{
		i++;
		sleep(1);
		printf("process things,i=%d!\n",i);
	}

	return 0;
}

在这里插入图片描述


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

void myfun(int signum)
{
	int i=0;
	while(i<10)
	{
		printf("process signal  signum=%d\n",signum);
		sleep(1);
		i++;
	}
	return ;
}
int main()
{
	int i=0;
	
	signal(14,myfun);
	printf("alarm before\n");
	alarm(9);
	printf("alarm after\n");
	signal(14,SIG_IGN);

	while(i<20)
	{
		i++;
		sleep(1);
		printf("process things,i=%d!\n",i);
	}

	return 0;
}

在这里插入图片描述


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

void myfun(int signum)
{
	int i=0;
	while(i<10)
	{
		printf("process signal  signum=%d\n",signum);
		sleep(1);
		i++;
	}
	return ;
}
int main()
{
	int i=0;
	
	signal(14,myfun);
	printf("alarm before\n");
	alarm(9);
	printf("alarm after\n");
	signal(14,SIG_IGN);
	signal(14,SIG_DFL);
	while(i<20)
	{
		i++;
		sleep(1);
		printf("process things,i=%d!\n",i);
	}

	return 0;
}

在这里插入图片描述

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

void myfun(int signum)
{
	int i=0;
	while(i<5)
	{
		printf("receive signum=%d,i=%d\n",signum,i);
		sleep(1);
		i++;
	}
	return ;
}

void myfun1(int signum)
{
	printf("receive signum=%d\n",signum);
	wait(NULL);
	return;
}

int main()
{
	pid_t pid;
	pid=fork();
	if(pid>0)
	{
		int i=0;
		signal(10,myfun);
		signal(17,myfun1);
		while(1)
		{
			printf("parent process things,i=%d\n",i);
			sleep(1);
			i++;
		}
	}
	if(pid==0)
	{
		sleep(10);
		kill(getppid(),10);
		sleep(10);
		exit(0);//kill(getppid(),17);
	}

	return 0;
}

在这里插入图片描述
在这里插入图片描述

共享内存

IPC通信：IPC对象{共享内存，消息队列，信号灯}–》内核空间

特点：
1）共享内存创建后，一直存在于内核中，直到被删除或系统关闭
2）共享内存和管道不一样，读取后，内容仍然在其共享内存中

1）创建或打开：shmget
int shmget(key_t key,int size,int shmflg权限);
key:1）IPC宏—>key=0，只能实现有亲缘关系的进程间的通信
2）ftok（key不一样）可以实现非亲缘关系的进程间的通信

char ftok（const char *path,char key）
第一个参数：文件路径和文件名
第二个参数：一个字符
返回值：正确返回key值，错返回-1

shmat 将共享内存映射到用户空间的地址中
void *shmat(int shmid,const void *shmaddr,int shmflg);
第一个参数：ID号
第二个参数：映射到的地址，NULL为系统自动完成的映射；
第三个参数：shmflg SHM_RDONLY共享内存只读
默认是0，表示共享内存可读写
返回值：成功：映射后的地址
失败：NULL

shmdt:将进程里的地址映射删除
int shmdt(const void* shmaddr);
参数：shmaddr共享内存映射后的地址
返回值：成功0 失败-1

shmctl:删除共享内存对象
int shmctl(int shmid,int cmd,struct shmid_ds,*buf);
参数：shmid:要操作的共享内存标识符
cmd:IPC_STAT(获取对象属性)–实现了命令ipcs-m
IPC_SET(设置对象属性)
IPC_RMID(删除对象)–实现了命令ipcrm -m
buf:指定IPC_STAT/IPC_SET时用以保存、设置属性
函数返回值： 成功 0 失败 -1


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

int main()
{
	int shmid;

	shmid=shmget(IPC_PRIVATE,128,0777);
	
	if(shmid<0)
	{
		perror("create share memory failure!");
		exit(1);
	}
	printf("create share memory success shmid=%d\n",shmid);

	system("ipcs -m");
//	system("ipcrm -m shmid");
	return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


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

int main()
{
	int shmid;
	int key;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		perror("create key failure!");
		exit(1);
	}
	printf("create key success! key=%d\n",key);
	shmid=shmget(key,128,IPC_CREAT|0777);
	
	if(shmid<0)
	{
		perror("create share memory failure!");
		exit(1);
	}
	printf("create share memory success shmid=%d\n",shmid);

	system("ipcs -m");
//	system("ipcrm -m shmid");
	return 0;
}

在这里插入图片描述


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

int main()
{
	int shmid;
	int key;
	char *p;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		perror("create key failure!");
		exit(1);
	}
	printf("create key success! key=%d\n",key);
	shmid=shmget(key,128,IPC_CREAT|0777);
	
	if(shmid<0)
	{
		perror("create share memory failure!");
		exit(1);
	}
	printf("create share memory success shmid=%d\n",shmid);

	system("ipcs -m");

	p=(char*)shmat(shmid,NULL,0);
	
	if(p==NULL)
	{
		perror("shmat function failure!");
		exit(1);
	}

	//write share memory
	fgets(p,128,stdin);

	//start read share memory
	printf("share memory data:%s\n",p);

	printf("second read memory data:%s\n",p);

//	system("ipcrm -m shmid");
	return 0;
}

在这里插入图片描述
在这里插入图片描述

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

int main()
{
	int shmid;
	int key;
	char *p;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		perror("create key failure!");
		exit(1);
	}
	printf("create key success! key=%d\n",key);
	shmid=shmget(key,128,IPC_CREAT|0777);
	
	if(shmid<0)
	{
		perror("create share memory failure!");
		exit(1);
	}
	printf("create share memory success shmid=%d\n",shmid);

	system("ipcs -m");

	p=(char*)shmat(shmid,NULL,0);
	
	if(p==NULL)
	{
		perror("shmat function failure!");
		exit(1);
	}

	//write share memory
	fgets(p,128,stdin);

	//start read share memory
	printf("share memory data:%s\n",p);

	printf("second read memory data:%s\n",p);

	shmdt(p);

//	memcpy(p,"abcd",4);//用以验证已经删除

//	system("ipcrm -m shmid");
	return 0;
}

在这里插入图片描述
在这里插入图片描述

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

int main()
{
	int shmid;
	int key;
	char *p;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		perror("create key failure!");
		exit(1);
	}
	printf("create key success! key=%d\n",key);
	shmid=shmget(key,128,IPC_CREAT|0777);
	
	if(shmid<0)
	{
		perror("create share memory failure!");
		exit(1);
	}
	printf("create share memory success shmid=%d\n",shmid);

	system("ipcs -m");

	p=(char*)shmat(shmid,NULL,0);
	
	if(p==NULL)
	{
		perror("shmat function failure!");
		exit(1);
	}

	//write share memory
	fgets(p,128,stdin);

	//start read share memory
	printf("share memory data:%s\n",p);

	printf("second read memory data:%s\n",p);

	shmdt(p);

//	memcpy(p,"abcd",4);//用以验证已经删除

	shmctl(shmid,IPC_RMID,NULL);
	system("ipcs -m");
//	system("ipcrm -m shmid");
	return 0;
}

在这里插入图片描述

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

int main(int argc,char*argv[])
{
	int shmid;
	if(argc<3)
	{
		printf("please input param\n");
		return -1;
	}
	if(strcmp(argv[1],"-m")==0)
	{
		printf("delete share memory\n");
	}
	else return -2;

	shmid=atoi(argv[2]);
	printf("shmid=%d\n",shmid);
	shmctl(shmid,IPC_RMID,NULL);

	system("ipcs -m");

	return 0;
}

在这里插入图片描述

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

void myfun(int signum)
{
	return ;
}

int main()
{
	int shmid;
	int key;
	char *p;
	int pid;
	shmid=shmget(IPC_PRIVATE,128,IPC_CREAT|0777);
	
	if(shmid<0)
	{
		perror("create share memory failure!");
		exit(1);
	}
	printf("create share memory success shmid=%d\n",shmid);

	pid=fork();

	if(pid>0)
	{
		signal(SIGUSR2,myfun);
		p=(char*)shmat(shmid,NULL,0);
	
		if(p==NULL)
		{
			perror("parent process:shmat function failure!");
			exit(1);
		}
		while(1)
		{
			printf("parent process start write share memory:\n");
			//write share memory
			fgets(p,128,stdin);
			kill(pid,SIGUSR1);//child process read data
			pause();
		}
	}
	if(pid==0)
	{
		p=(char*)shmat(shmid,NULL,0);

		if(p==NULL)
		{
			printf("child process shmat function failure!\n");
			return -3;
		}
		while(1)
		{
			signal(SIGUSR1,myfun);
			pause();//wait parent process write
			//start read share memory
			printf("share memory data:%s\n",p);
			kill(getppid(),SIGUSR2);
		}
	}
	shmdt(p);
	shmctl(shmid,IPC_RMID,NULL);
	system("ipcs -m");
	return 0;
	
}

在这里插入图片描述

server.c

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

struct mybuf
{
	int pid;
	char buf[124];
};

void myfun(int signum)
{
	return ;
}

int main()
{
	int shmid;
	int key;
	struct mybuf *p;
	int pid;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("create key failure!\n");
		return -1;
	}
	printf("create key success!\n");
	shmid=shmget(key,128,IPC_CREAT|0777);
	
	if(shmid<0)
	{
		perror("create share memory failure!");
		exit(1);
	}
	printf("create share memory success shmid=%d\n",shmid);
	
		signal(SIGUSR2,myfun);
		p=(struct mybuf*)shmat(shmid,NULL,0);
	
		if(p==NULL)
		{
			perror("parent process:shmat function failure!");
			exit(1);
		}
		//get client pid
		p->pid=getpid();//write server pid to memory

		pause();//wait client read server pid;

		pid=p->pid;


		//white
		while(1)
		{
			printf("parent process start write share memory:\n");
			//write share memory
			fgets(p->buf,128,stdin);
			kill(pid,SIGUSR1);//client process read data
			pause();//wait client process read
		}
	
	shmdt(p);
	shmctl(shmid,IPC_RMID,NULL);
	system("ipcs -m");
	return 0;
	
}

client.c

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

struct mybuf
{
	int pid;
	char buf[124];
};

void myfun(int signum)
{
	return ;
}

int main()
{
	int shmid;
	int key;
	struct mybuf *p;
	int pid;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("create key failure!\n");
		return -1;
	}
	printf("create key success!\n");
	shmid=shmget(key,128,IPC_CREAT|0777);
	
	if(shmid<0)
	{
		perror("create share memory failure!");
		exit(1);
	}
	printf("create share memory success shmid=%d\n",shmid);
	
		signal(SIGUSR1,myfun);
		p=(struct mybuf*)shmat(shmid,NULL,0);
	
		if(p==NULL)
		{
			perror("parent process:shmat function failure!");
			exit(1);
		}
		//get server pid
		//read share memory
		pid=p->pid;

		//write client pid to share memory
		p->pid=getpid();
		//kill signal
		kill(pid,SIGUSR2);

		//client start read data from share memory
		while(1)
		{
			pause();//wait server write data to share memory;
			printf("client process receive data from share memory:%s\n",p->buf);//read data
			kill(pid,SIGUSR2);//server may write share memory
		}
	
	shmdt(p);
	shmctl(shmid,IPC_RMID,NULL);
	system("ipcs -m");
	return 0;
	
}

在这里插入图片描述

消息队列

创建消息队列
int msgget(key_t key, int flag);
参数：和消息队列关联的key的值
flag：消息队列的访问权限
返回值：消息队列ID 失败-1

删除
int msgctl(int msgqid,int cmd,struct msqid_ds *buf)
参数：第一个：消息队列的队列ID
第二个：IPC_STAT：读属性，并保存在buf指定的缓冲区中
IPC_SET:设置消息队列属性，这个值取自buf参数
IPC_RMID：从系统中删除消息队列
第三个参数：消息队列缓冲区

函数返回值：成功返回 0 失败返回-1

在这里插入图片描述
在这里插入图片描述
读完就删
int msgrcv(int msgid,void*msgp,size_t size,long msgtype,int flag);


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

int main()
{
	int msgid;

	msgid=msgget(IPC_PRIVATE,0777);
	
	if(msgid<0)
	{
		perror("create message queue failure!");
		exit(1);
	}
	printf("create message queue success msgid=%d\n",msgid);

	system("ipcs -q");
//	system("ipcrm -m shmid");
	return 0;
}

在这里插入图片描述


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

int main()
{
	int msgid;

	msgid=msgget(IPC_PRIVATE,0777);
	
	if(msgid<0)
	{
		perror("create message queue failure!");
		exit(1);
	}
	printf("create message queue success msgid=%d\n",msgid);

	system("ipcs -q");

	//delete  message queue
	msgctl(msgid,IPC_RMID,NULL);
	system("ipcs -q");

	return 0;
}

在这里插入图片描述

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

struct msgbuf
{
	long type;
	char voltage[124];
	char ID[4];
};

int main()
{
	int msgid;
	struct msgbuf sendbuf;
	msgid=msgget(IPC_PRIVATE,0777);
	
	if(msgid<0)
	{
		perror("create message queue failure!");
		exit(1);
	}
	printf("create message queue success msgid=%d\n",msgid);

	system("ipcs -q");
	//init sendbuf
	
	sendbuf.type=100;
	printf("please input message:\n");
	fgets(sendbuf.voltage,124,stdin);

	//start write message to message queue
	
	msgsnd(msgid,(void*)&sendbuf,strlen(sendbuf.voltage),0);

	while(1);

	//delete  message queue
	msgctl(msgid,IPC_RMID,NULL);
	system("ipcs -q");

	return 0;
}

在这里插入图片描述

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

struct msgbuf
{
	long type;
	char voltage[124];
	char ID[4];
};

int main()
{
	int readret;
	int msgid;
	struct msgbuf sendbuf,recvbuf;
	msgid=msgget(IPC_PRIVATE,0777);
	
	if(msgid<0)
	{
		perror("create message queue failure!");
		exit(1);
	}
	printf("create message queue success msgid=%d\n",msgid);

	system("ipcs -q");
	//init sendbuf
	
	sendbuf.type=100;
	printf("please input message:\n");
	fgets(sendbuf.voltage,124,stdin);

	//start write message to message queue
	
	msgsnd(msgid,(void*)&sendbuf,strlen(sendbuf.voltage),0);

	//start read message from message queue
	memset(recvbuf.voltage,0,124);
	readret=msgrcv(msgid,(void*)&recvbuf,124,100,0);
	printf("recv:%s\n",recvbuf.voltage);
	printf("readret=%d\n",readret);
	//second read message queue
//	msgrcv(msgid,(void*)&recvbuf,124,100,0);
//	printf("second read after!");
	//delete  message queue
	msgctl(msgid,IPC_RMID,NULL);
	system("ipcs -q");

	return 0;
}

在这里插入图片描述
实现单向通信

write.c

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

struct msgbuf
{
	long type;
	char voltage[124];
	char ID[4];
};

int main()
{
	int readret;
	int msgid;
	int key;
	struct msgbuf sendbuf,recvbuf;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("create key failure!\n");
		return -2;
	}
	msgid=msgget(key,IPC_CREAT|0777);
	
	if(msgid<0)
	{
		perror("create message queue failure!");
		exit(1);
	}
	printf("create message queue success msgid=%d\n",msgid);

	system("ipcs -q");

	sendbuf.type=100;
	//write message queue
	while(1)
	{
		memset(sendbuf.voltage,0,124);//clear send buffer

		printf("please input message:\n");
		fgets(sendbuf.voltage,124,stdin);

		//start write message to message queue
	
		msgsnd(msgid,(void*)&sendbuf,strlen(sendbuf.voltage),0);
	}
	msgctl(msgid,IPC_RMID,NULL);
	system("ipcs -q");

	return 0;
}

read.c

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

struct msgbuf
{
	long type;
	char voltage[124];
	char ID[4];
};

int main()
{
	int readret;
	int msgid;
	int key;
	struct msgbuf sendbuf,recvbuf;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("create key failure!\n");
		return -2;
	}
	msgid=msgget(key,IPC_CREAT|0777);
	
	if(msgid<0)
	{
		perror("create message queue failure!");
		exit(1);
	}
	printf("create message queue success msgid=%d\n",msgid);

	system("ipcs -q");

	//read message queue
	while(1)
	{
		memset(recvbuf.voltage,0,124);//clear recv buffer

		//start read message from message queue
	
		msgrcv(msgid,(void*)&recvbuf,124,100,0);
		printf("recvive data from message queue:%s\n",recvbuf.voltage);
	}
	msgctl(msgid,IPC_RMID,NULL);
	system("ipcs -q");

	return 0;
}

在这里插入图片描述
实现双向通信

msgserver.c

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

struct msgbuf
{
	long type;
	char voltage[124];
	char ID[4];
};

int main()
{
	int readret;
	int msgid;
	int key;
	int pid;
	struct msgbuf sendbuf,recvbuf;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("create key failure!\n");
		return -2;
	}
	msgid=msgget(key,IPC_CREAT|0777);
	
	if(msgid<0)
	{
		perror("create message queue failure!");
		exit(1);
	}
	printf("create message queue success msgid=%d\n",msgid);

	system("ipcs -q");

	pid=fork();
	if(pid>0)//parent process write 100
	{
		sendbuf.type=100;
		//write message queue
		while(1)
		{
			memset(sendbuf.voltage,0,124);//clear send buffer

			printf("please input message:\n");
			fgets(sendbuf.voltage,124,stdin);

			//start write message to message queue
	
			msgsnd(msgid,(void*)&sendbuf,strlen(sendbuf.voltage),0);
		}
	}
	if(pid==0)//child process read 200
	{
		while(1)
		{
			memset(recvbuf.voltage,0,124);
			msgrcv(msgid,(void *)&recvbuf,124,200,0);
			printf("receive message from message queue:%s\n",recvbuf.voltage);

		}	
	}
	msgctl(msgid,IPC_RMID,NULL);
	system("ipcs -q");

	return 0;
}

msgclient.c

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

struct msgbuf
{
	long type;
	char voltage[124];
	char ID[4];
};

int main()
{
	int readret;
	int msgid;
	int key;
	int pid;
	struct msgbuf sendbuf,recvbuf;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("create key failure!\n");
		return -2;
	}
	msgid=msgget(key,IPC_CREAT|0777);
	
	if(msgid<0)
	{
		perror("create message queue failure!");
		exit(1);
	}
	printf("create message queue success msgid=%d\n",msgid);

	system("ipcs -q");

	pid=fork();
	if(pid==0)//child process write 200
	{
		sendbuf.type=200;
		//write message queue
		while(1)
		{
			memset(sendbuf.voltage,0,124);//clear send buffer

			printf("please input message:\n");
			fgets(sendbuf.voltage,124,stdin);

			//start write message to message queue
	
			msgsnd(msgid,(void*)&sendbuf,strlen(sendbuf.voltage),0);
		}
	}
	if(pid>0)//parent process read 100
	{
		while(1)
		{
			memset(recvbuf.voltage,0,124);
			msgrcv(msgid,(void *)&recvbuf,124,100,0);
			printf("receive message from message queue:%s\n",recvbuf.voltage);

		}	
	}
	msgctl(msgid,IPC_RMID,NULL);
	system("ipcs -q");

	return 0;
}

在这里插入图片描述

信号灯

信号灯和信号量区别：
信号量：单个信号量
信号灯：信号量的集合
这里面的函数都是针对集合
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
创建：
int semget(key_t key,int nsems,int semflg)
参数：
第一个：和信号灯集有关的key值
第二个：信号灯集中包含的信号灯数目
第三个：信号灯集合的访问权限
返回值：成功返回信号灯集ID，错-1

删除、初始化
int semctl(int semid,int semnum,int cmd,…union semun arg(不是地址))；
参数：semid:信号灯集ID
semnum:要修改的信号灯编号
cmd：GETVAL:获取信号灯的值
SETVAL:设置信号灯的值
IPC_RMID:从系统中删除信号灯集合
返回值：成功0 失败-1


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

int main()
{
	int semid;

	semid=semget(IPC_PRIVATE,3,0777);
	
	if(semid<0)
	{
		perror("create semaphore failure!");
		exit(1);
	}
	printf("create semaphore success semid=%d\n",semid);

	system("ipcs -s");
//	system("ipcrm -m shmid");
	return 0;
}

在这里插入图片描述


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

int main()
{
	int semid;

	semid=semget(IPC_PRIVATE,3,0777);
	
	if(semid<0)
	{
		perror("create semaphore failure!");
		exit(1);
	}
	printf("create semaphore success semid=%d\n",semid);

	system("ipcs -s");

	//delete semaphore
	semctl(semid,0,IPC_RMID,NULL);
	system("ipcs -s");
	return 0;
}

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<unistd.h>
#include<semaphore.h>

sem_t sem;

void* fun(void *var)//child thread code
{
	int j;
	//p wait
	sem_wait(&sem);//sleep
	for(j=0;j<10;j++)
	{
	//	usleep(100);
		printf("this is fun j=%d\n",j);
	}
}

int main()//main thread code
{
	int i;
	char str[]="hello linux\n";
	pthread_t tid;
	int ret;
	sem_init(&sem,0,0);//sem=0
	ret=pthread_create(&tid,NULL,fun,(void*)str);
	if(ret<0)
	{
		perror("create pthread error!");
		exit(1);
	}
	for(i=0;i<10;i++)
	{
		usleep(100);
		printf("this is main fun i=%d\n",i);
	}

	sem_post(&sem);
	while(1);

	return 0;

}

在这里插入图片描述

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

union semun
{
	int val;
	struct semid_ds *buf;
	unsigned short *array;
	struct seminfo *__buf;
};

int semid;
union semun mysemun;
struct sembuf mysembuf;
void* fun(void *var)//child thread code
{
	int j;
	//p wait
	mysembuf.sem_op=-1;
	semop(semid,&mysembuf,1);
	for(j=0;j<10;j++)
	{
	//	usleep(100);
		printf("this is fun j=%d\n",j);
	}
}

int main()//main thread code
{
	int i;
	char str[]="hello linux\n";
	pthread_t tid;
	int ret;
	semid=semget(IPC_PRIVATE,3,0777);
	if(semid<0)
	{
		printf("create semaphore failure!\n");
		return -1;
	}
	printf("create semaphore success,semid=%d\n",semid);
	system("ipcs -s");
	mysemun.val=0;
	semctl(semid,0,SETVAL,mysemun);
	
	mysembuf.sem_num=0;
	mysembuf.sem_flg=0;
	ret=pthread_create(&tid,NULL,fun,(void*)str);
	if(ret<0)
	{
		perror("create pthread error!");
		exit(1);
	}
	for(i=0;i<10;i++)
	{
		usleep(100);
		printf("this is main fun i=%d\n",i);
	}

	//v
	mysembuf.sem_op=1;
	semop(semid,&mysembuf,1);
	while(1);

	return 0;

}

在这里插入图片描述
下面这个先运行客户端，在运行服务器

semclient.c

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

union semun
{
	int val;
	struct semid_ds *buf;
	unsigned short *array;
	struct seminfo *__buf;
};

int semid;
union semun mysemun;
struct sembuf mysembuf;

int main()//main thread code
{
	int i;
	int key;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("create key failure!\n");
		return -3;
	}
	printf("create key success!\n");
	semid=semget(key,3,IPC_CREAT|0777);
	if(semid<0)
	{
		printf("create semaphore failure!\n");
		return -1;
	}
	printf("create semaphore success,semid=%d\n",semid);
	system("ipcs -s");
	//init sem
	mysemun.val=0;
	semctl(semid,0,SETVAL,mysemun);
	
	mysembuf.sem_num=0;
	mysembuf.sem_flg=0;
	//P  wait
	mysembuf.sem_op=-1;
	semop(semid,&mysembuf,1);
	for(i=0;i<10;i++)//second
	{
		usleep(100);
		printf("this is client fun i=%d\n",i);
	}

	//v
//	mysembuf.sem_op=1;
//	semop(semid,&mysembuf,1);
	while(1);

	return 0;

}

semserver.c

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

union semun
{
	int val;
	struct semid_ds *buf;
	unsigned short *array;
	struct seminfo *__buf;
};

int semid;
union semun mysemun;
struct sembuf mysembuf;

int main()//main thread code
{
	int i;
	int key;
	key=ftok("./a.c",'a');
	if(key<0)
	{
		printf("create key failure!\n");
		return -3;
	}
	printf("create key success!\n");
	semid=semget(key,3,IPC_CREAT|0777);
	if(semid<0)
	{
		printf("create semaphore failure!\n");
		return -1;
	}
	printf("create semaphore success,semid=%d\n",semid);
	system("ipcs -s");
	//init sem
	mysemun.val=0;
	semctl(semid,0,SETVAL,mysemun);
	
	mysembuf.sem_num=0;
	mysembuf.sem_flg=0;
	for(i=0;i<10;i++)//first
	{
		usleep(100);
		printf("this is server fun i=%d\n",i);
	}

	//v
	mysembuf.sem_op=1;
	semop(semid,&mysembuf,1);
	while(1);

	return 0;

}

在这里插入图片描述

&*Savior
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
非亲缘关系的进程实现通信（利用多线程），有名管道
weixin_51028471的博客
11-16 212
【代码】非亲缘关系的进程实现通信（利用多线程），有名管道。
消息队列-无亲缘关系进程通信
suxusong的博客
07-08 1647
消息队列不像共享内存的流程，它不需要信号通知。 消息队列的另一个特点：信息读取完自动删除；可以阻塞 msgget函数： 消息队列创建 头文件： #include <sys/types.h>      #include <sys/ipc.h>      #include <sys/msg.h> 函数原型： int msgget(key_t key, int flag); 参数： key，和消息队列关联的key值     flag，消息队列的访问权 返回： 成功，消息队列ID
linux之通过一个文件实现父子进程间通信
发如雪
08-07 466
代码：fork_shared_fd.c #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <string.h> #include <sys/wait.h> void sys_err(const c
Linux之文件通信
diaohong5075的博客
08-07 153
/* * 后执行,尝试读取另外一个进程写入文件的内容 */ #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <fcntl.h> #include <string.h> int main(void) { ...
linux消息队列非亲缘,linux进程
weixin_39943992的博客
05-16 130
linux进程Tag内容描述：1、linux消息队列进程通信 一、消息队列的基本概念消息队列(也叫做报文队列)是Unix系统V版本中3种进程间通信机制之一。另外两种是信号灯和共享内存。这些IPC机制使用共同的授权方法。只有通过系统调用将标志符传递给核心之后，进程才能存取这些资源。这种系统IPC对象使用的控制方法和文件系统非常类似。使用对象的引用标志符作为资源表中的索引。 消息队列就是一个消息的链表...
Linux进程间通信课件代码.rar
04-03
【标题】"Linux进程间通信课件代码.rar" 提供了一组示例代码和相关学习材料，重点关注Linux操作系统中进程间通信（IPC, Inter-Process Communication）这一关键主题。在这个压缩包里，我们可以找到多个C语言编写的源...
B端产品经理如何自学提升
最新发布
07-11
B端产品经理如何自学提升
电子工程师自学速成 设计篇 _设计篇_电子工程师自学速成_
10-03
《电子工程师自学速成 设计篇》是一本专为电子工程师设计的自学教程，共534页，包含了丰富的理论知识和实践经验。该书以58.3M的超大容量，提供了高清书签版，方便读者查阅和学习。这份资料的标签明确地指出其核心...
UNIX网络编程第2卷进程间通信
11-29
本书全面深入地讲述了各种进程间通信(IPC)形式，它们是几乎所有复杂精致的UNIX程序的性能之关键。从网络编程角度看，理解IPC也是理解如何开发不同主机间网络应用程序的必要条件。本书从对Posix IPC和System V IPC的...
Linux系统编程第05期：进程间通信
06-14
本视频教程为《Linux系统编程》第05期，本期课程将会带领大家学习Linux下将近15种进程间通信IPC工具的使用，了解它们的通信机制、编程实例、使用场景、内核中的实现以及各自的优缺点。 本课程会提供PDF版本的PPT课件...
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
07-07
说明：编译时加上参数 -lrt -lpthread 要不然找不到库文件
消息队列实现进程间通信
laoKdx的博客
08-06 1332
消息队列，实现进程间通信
进程之间的通信方式
LittleCadet
04-02 341
进程之间需要通信的原因：即使只有一个用户发出要求，也可能导致一个操作系统中多个进程的运行，进程之间必须互相通话。进程之间的通信方式有6种：管道和有名管道，信号，消息队列，共享内存，信号量，套接字 （记忆方式：管信消，共信套）1.管道及有名管道：    前者：具有亲缘关系的父子进程间的通信    后者：有无亲缘关系均可。2.信号：  在软件层上对终端机制的一种模拟，通知有事发生，与处理器收到一个中断...
进程间通信 -- 消息队列
xuechanba的博客
04-22 1869
管道 内核提供，单工，自同步机制 自同步机制：迁就慢的那一方，两个进程在使用管道通信时，一端为读端，一端为写端。假设读端很快，写端速度很慢，那么读端很快就会将管道给读空，如果当前管道读空，但是写端仍然存在的话，作为读端，你要一直在那等待，等到写端写数据到管道)。 匿名管道：pipe(); 命名管道：mkfifo(); XSI IPC XSI IPC源自于系统V的IPC功能。 IPC是进程间通信Inter-Process Communication的缩写， 有三种IPC我们称作XSI IPC，即消息队列、信号
Linux 进程 | 进程间的通信方式
Jormungand_V的博客
08-13 341
文章目录 在之前的博客中讲过，虚拟空间出现的其中一个目的就是解决 进程没有独立性，可能访问同一块物理内存 的问题。因为这种独立性，进程之间无法直接进行通信，操作系统为了解决这种问题，提出了多种适用于不同情境下的通信方式： 数据传输：管道、消息队列 数据共享：共享内存 进程控制：信号量 ...
共享内存-父子进程、非亲缘关系进程通信
suxusong的博客
07-08 1854
IPC：共享内存、信号灯、消息队列 共享内存的特点： 共享内存创建后一直存在于内核中，直到被删除或系统关闭； 共享内存和管道不一样，读取后，内容仍然存在。 shm_get函数： 共享内存的创建 头文件： #include <sys/types.h>      #include <sys/ipc.h>      #include <sys/shm.h> 函数原型： int shmget(key_t key, int size, int shmflg) 函数参数： key：I
linux无权限open_Linux非亲缘进程间通信：有名管道
weixin_36033516的博客
01-22 178
图控大叔构图传递思想阅读从未如此简单！！！01前言 今天来说说Linux进程间通信：匿名管道。Linux环境下，进程间的通信方式有很多，有管道，IPC机制下的消息队列、共享内存和信号量，Posix机制下的有名信号量和无名信号量。今天要分享的内容是亲缘进程间的通信方式：匿名管道。待分享的内容还很多，慢慢来！02细述有名管道特点有名管道特点1，他能够作用无任何亲缘关系的进程...
《Linux操作系统》进程间通信
....
12-09 1932
一、填空题 1.Linux系统中使用的进程通信机制包括管道通信、、、以及socket通信。 2.管道采用方式进行通信,其实质是由管理的一个缓冲区。 3. 与管道相比，消息队列通信方式更为灵活:它提供有格式的_____，无须通信双 方额外约定数据传输格式;其中的消息被设定为不同类型，又被分配了不同的优先级;此外 消息队...
Linux C编程之十一 进程间通信
weixin_30955341的博客
05-14 175
一、整体大纲 二、进程间通信概念及方法 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess ...
Mina2.0 TCP/IP通信完全自学指南
教程涵盖了Mina的远程通信、基础概念、实例应用以及其他相关内容，适用于完全自学。" Mina2.0是Apache基金会的一个网络应用框架，主要用于构建高性能、高可扩展性的网络应用程序。它基于Java NIO（Non-blocking I/O...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

&*Savior

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值