进程间通信——FIFO

同一个主机的进程间通信：

1. 无名管道（PIPE）——适用与任何同主机进程（多亲缘关系进程）——管道是单向的，多进程使用同一管道会产生交叉读写的问题
2. 有名管道（FIFO）——依赖文件系统，实现不同进程对文件系统下某个文件的访问
3. 消息队列（Message Queue）——同主机任意多进程间通信——存放的数据量有限，适用与少量数据传递
4. 共享内存（Share Memory）——同主机任意进程间大量数据通信——数据访问存在竞争问题
5. 信号（Signal）——同主机进程间同步机制
6. 信号量（semaphore）——同主机进程间异步机制

网络主机间进程通信：

1. RPC
2. 套接口（Socket）

有名管道和普通文件一样具有磁盘路径，文件权限等属性，但是有名管道并没又在磁盘中存放真正的信息，他存放的通信信息在内存中，两个进程结束后丢失

 

创建有名管道：

mkfifo（要创建的管道文件名，生成文件的模式）

该文件必须不存在

 

读写有名管道：

先open()打开文件，在readI()/write()

如果以某种方式打开有名管道，那么系统将阻塞，知道另一进程以另一种方式打开管道才会继续执行

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

void handler(int sig)
{
        printf("sig=%d\n",sig);
        }

int main(void)
{
        int j;
        signal(SIGPIPE,handler);//设置某一信号的对应动作,第一个指所要处理的信号类型,handler描述了与信号关联的动作，当接收到一个类型为sig的信号时，就执行handler 所指定的函数
        unlink("FIFO");//删除原来的管道
        mkfifo("FIFO",0644);
        pid_t pid;
        pid=fork();
        if(pid==0)
        {
                int fd;
                fd=open("FIFO",O_RDONLY);
                close(fd);
                }
        else
        {
                int fd;
                fd=open("FIFP",O_WRONLY);
                int ret;
                sleep(1);
                ret=write(fd,"helloworld",10);
                printf("ret=%d\n",ret);
                }
        }

非亲源渐进成使用有名管道通信：

发送数据write

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

#define FIFO_NAME "/tmp/my_fifo"

int main(int argc,char* argv[])
{
        int pipe_fd;
        int res;
        char buffer[]="hello world!";
        if(access(FIFO_NAME,F_OK)==-1)//文件是否存在,不存在才能创建有名管道
        {
                res=mkfifo(FIFO_NAME,0766);
                if(res!=0)
                {
                        fprintf(stderr,"could not creat fifo %s\n",FIFO_NAME);
                        exit(EXIT_FAILURE);
                        }
                }
        printf("process %d opening FIFO O_WRONLY\n",getpid());
        pipe_fd=open(FIFO_NAME,O_WRONLY);//以只写的方式打开有名管道
        printf("the file's description is %d\n",pipe_fd);
        if(pipe_fd!=-1)
        {
                res=write(pipe_fd,buffer,sizeof(buffer));
                if(res==-1)
                {
                        fprintf(stderr,"write error on pipe\n");
                        exit(EXIT_FAILURE);
                        }
                printf("write data is %s,%d bytes is write\n",buffer,res);
                close(pipe_fd);
                }
        else
                exit(EXIT_FAILURE);
        printf("process %d finished\n",getpid());
        exit(EXIT_FAILURE);
        }

[root@sun fifo]# ./not_parent_task_write
process 3356 opening FIFO O_WRONLY　　　　//阻塞，等待read
the file's description is 3　　　　　　　　　　　　//read执行后出现
write data is hello world!,13 bytes is write
process 3356 finished

读取数据read

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

#define FIFO_NAME "/tmp/my_fifo"

int main(int argc,char* argv[])
{
        int pipe_fd;
        int res;
        char buffer[4096];
        int bytes_read=0;
        memset(buffer,'\0',sizeof(buffer));
        printf("process %d opening FIFO O_RDONLY\n",getpid());
        pipe_fd=open(FIFO_NAME,O_RDONLY);
        printf("the file's description is %d\n",pipe_fd);
        if(pipe_fd!=-1)
        {
                bytes_read=read(pipe_fd,buffer,sizeof(buffer));
                printf("the read data is %s\n",buffer);
                close(pipe_fd);
                }
        else
                exit(EXIT_FAILURE);
        printf("process %d finished,%d bytes read\n",getpid(),bytes_read);
        exit(EXIT_FAILURE);
        }

[root@sun fifo]# ./not_parent_task_read
process 3393 opening FIFO O_RDONLY
the file's description is 3
the read data is hello world!
process 3393 finished,13 bytes read