多任务——进程间通信（管道、消息队列、共享内存、信号量）

进程间通信

前言：每个进程都是独立的，内核空间为1G，用户空间为3G，由于用户空间是独立的，所以只能借助内核空间进行进程间通信。

一、什么叫进程间通信？
进程间通信又叫做IPC，指的是多个进程之间相互通信交换信息的方法。

广义上的进程间通信：
A——文件——B
A——数据库——B

狭义上的进程间通信：
管道（无名管道、有名管道）、消息队列、共享内存、信号、信号量、套接字

二、管道、消息队列、共享内存、信号、信号量的使用方法

管道

管道分为无名管道和有名管道
无名管道——只能用于父子进程之间，使用pipe函数来构造一个无名管道，下面举例：

/*注意：用pipe创建管道时，要注意，应该先创建pipe函数，然后再使用fork函数创建父子进程。
如果将pipe函数放在fork后面，那么会生成两个管道，这种做法是错误的*/
#include<stdio.h>
#include<string.h>//字符串 头文件
#include<sys/types.h>//pid_t类型  头文件
#include<unistd.h>//pipe函数  头文件
#include<stdlib.h>//perror函数  头文件

int main()
{
	int fd[2];//创建两个文件描述符
	pid_t pid;
	pipe(fd);//创建无名管道
	pid=fork();//创建父子进程

	if(pid<0)
	{
		perror("fork error!\n");
		exit(1);
	}
	//fd[0]读文件，fd[1]写文件
	if(pid==0)
	{
		close(fd[0]);
		write(fd[1],"hello world",11);
	}
	else if(pid>0)
	{
		close fd[1];
		char buffer[100];
		int n=read（fd[0],buffer,sizeof(buffer));
		buffer[n]='\0';
		printf("%s\n",buffer);
	}
	return 0;
}

有名管道
允许无亲缘关系的进程间通信，使用mkfifo函数来生成有名管道，下面举例：
不同进程之间就可以对同一个文件进行读写操作，从而实现进程间通信。

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

#define FILENAME "a.txt"

int main()
{
	 pid_t pid;
         int a=mkfifo(FILENAME,0666);//先创建一个特殊的fifo文件，如果返回值为-1，则创建失败
         if(a<0)
   	 {
       	        perror("mkfifo error\n");
        	return -1;
         }
         pid=fork();
         if(pid<0)
    	{
        	perror("fork error\n");
        	return -1;
    	}
    	if(pid==0)
    	{
        	int fd=open(FILENAME,O_CREAT|O_RDWR,0644);
        	if(fd<0)
        	{
            		perror("open file error\n");
        	}
        	char buffer[1024];
        	memset(buffer,0,sizeof(buffer));
      		getchar();
        	gets(buffer);
        	write(fd,buffer,strlen(buffer));
    	}
    	else if(pid>0)
    	{
        	int fd=open(FILENAME,O_CREAT|O_RDWR,0644);
        	if(fd<0)
        	{
            	perror("open file error\n");
        	}
        	char buffer[1024];
        	lseek(fd,0,SEEK_SET);
        	read(fd,buffer,strlen(buffer));
        	printf("read file=%s\n",buffer);
    	}
	return 0;
}

共享内存

共享内存就是映射一段能被其他进程所访问的内存。这段共享内存由一个进程创建，但多个进程都可以访问。让两个进程地址通过页表映射到同一片物理地址以便于通信,你可以给一个区域里面写入数据，也可以从中拿取数据，这也就构成了进程间的双向通信，而且共享内存是IPC通信当中传输速度最快的通信方式。

但是，共享内存也并不完美，共享内存并未提供同步机制，也就是说，在一个服务进程结束对共享内存的写操作之前，并没有自动机制可以阻止另一个进程（客户进程）开始对它进行读取。基于此，我们通常会用 信号量来实现对共享内存同步访问控制。

1)key可以指定为IPC_PRIVATE宏，创建新的消息队列
2)key可以指定为一个整数型，但是容易造成重复，所以使用ftok来生成key
ftok(文件路径名，整型数)，返回一个key

shmget创建共享内存，返回shmid值
shmat将物理内存映射到自己进程空间内
shmdt释放内存
shmctl删除共享内存

举例：

#include<stdio.h>
#include<sys/types.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<string.h>
#define MAXSIZE 1024
int main()
{
	pid_t pid;
    	//key_t key;
    	//int shmid=shmget(key,MAXSIZE,0644);
    //创建共享内存
    	int shmid=shmget(IPC_PRIVATE,MAXSIZE,0644);//成功返回共享内存的id，出错返回-1
    	if(shmid<0)
    	{
        	perror("shmget error\n");
        	exit(1);
    	}
    	pid=fork();
    	if(pid<0)
    	{
        	perror("fork error\n");
        	exit(1);
    	}
    	if(pid==0)
    	{
    //创建好共享内存后，将物理内存映射到自己进程空间内
        	char *addr=(char *)shmat(shmid,NULL,0);
        	char buffer[100];
        	menset(buffer,0,sizeof(buffer));
        	gets(buffer);
        	strcpy(addr,buffer);
    	}
    	else if(pid>0)
    	{
    //创建好共享内存后，将物理内存映射到自己进程空间内
        	char *addr=(char *)shmat(shmid,NULL,0)；
        	char buffer[100];
        	if(strlen(addr)!=0)
        	{
            		strcpy(buffer,addr);
             		printf("data=%s\n",buffer);
        	}
        	else
        	{
            		printf("no data.....\n");
        	}
        //释放内存
        	shmdt(addr);
        //操作共享内存——删除共享内存
        	shmctl(shmid,IPC_RMID,NULL);
    	}
	return 0;
}

消息队列
消息队列是有消息的，链表存放在内核中，并有消息队列标识标识符，消息队列克服了信号传递信息少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。

创建一个新的消息队列

key＝ftok(“./file”,'a')
int misgid＝msgget(key，0664|IPC_CREAT)

操作者得到消息队列misgid后，即可操作消息队列。
——msgsnd写操作
——mgscrv读操作
——msgctl删除操作

举例：

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<sys/msg.h>
#include<stdlib.h>
#include<unistd.h>
#include <sys/ipc.h>
#include<signal.h>
struct msgbuf
{
    int type;
    char mtext[1024];
};

int main()
{
	struct msgbuf sendbuf;
    	struct msgbuf recvbuf;
    	int msgid=msgget(IPC_PRIVATE,0777);
   	if(msgid<0)
    	{
        	perror("msgget error\n");
        	return -1;
    	}
    	printf("msgget successful!   msgid=%d\n",msgid);
    
    	printf("please input message:\n");
//send message
    	sendbuf.type=100;
    	fgets(sendbuf.mtext,1024,stdin);
    	msgsnd(msgid,(void*)&sendbuf,strlen(sendbuf.mtext),0);  
//read message
	memset(recvbuf.mtext,0,1024);
    	int readret=msgrcv(msgid,(void*)&recvbuf,1024,100,0);
    	printf("recv=%s\n",recvbuf.mtext);
    	printf("readret=%d\n",readret);
//delete
    	msgctl(msgid,IPC_RMID,NULL);  //删除msgid

	return 0;
}

信号量
当多个进程，线程进行共享操作时，用于保护资源，防止相互干扰。不是用于交换大批数据而用于多线程之间的同步，常作为一种锁机制，防止某进程在访问资源时其他进程也访问该资源。

信号量：mutex
信号量操作：PV操作
——P操作:锁，S－1，<0即被阻塞，停止操作
——V操作:开，S+1，>0则执行进程

互斥:mutex＝1允许一个进程，也就是二值信号量

当多个进程同时对同一个文件进行访问就需要多个信号量mutex

互斥和同步
当两个进程同时访问同一个文件时，不互斥会导致文件内容混乱

semget

semctl
semop