braveyly

浏览: 100689 次

最近访客更多访客>>

唐稚骅

zale_lzj

BestMy

大名叫飞飞

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

2013-12 ( 13)
2013-11 ( 19)
2013-10 ( 21)
更多存档...

IPC FIFO

FIFO

1、函数列表

Ø int mkfifo(const char *pathname, mode_t mode);

如果pathname指向的FIFO不存在，则创建FIFO，此时返回0；如果pathname指向的FIFO已经存在，则返回-1，errno==EEXIST。

关于mode，此函数已隐含包含O_CREATE和O_EXCL，也就是说要么创建一个新的FIFO，要么返回EEXIST错误。指定S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH表示FIFO允许用户读、用户写、组成员读和其他用户读。

Ø int open(const char *pathname, int flags, mode_t mode);

一个FIFO创建完后（或者是已经存在），它必须或者打开用于读，或者打开用于写。对于一个进程而言，FIFO不能打开来既读又写，因为FIFO是半双工的。

Ø ssize_t write(int fd, const void *buf, size_t count);

Ø ssize_t read(int fd, void *buf, size_t count);

Ø int close(int fd); //#include <unistd.h>

操作文件（广义的：包括普通文件、系统设备和管道）的读写关闭函数。其中fd为文件描述字。

Ø int unlink(const char *pathname);

此函数将FIFO从系统中彻底删除。成功返回0，失败返回-1。

2、实例解析

Ø Simplefifo

FIFO的基本使用，在父子进程中使用单个FIFO，父进程向FIFO的写文件描述字写进数据，子进程从FIFO的读文件描述字中读出数据。

//simplefifo.c

#include <sys/types.h>

#include <sys/stat.h>

#include <pthread.h>

#include <unistd.h>

#include <stdio.h>

#include <fcntl.h> //O_RDONLY

#include <errno.h>

#define MAX_LENGTH 10

int main(int argc, char **argv)

{

int readfd, writefd;

pid_t childpid;

int w_length;

int r_length;

char buffer[MAX_LENGTH];

if ((mkfifo("/tmp/fifo.1", (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))<0) && (errno == EEXIST))

printf("can't create %s", "/tmp/fifo.1");

if((childpid=fork())==0) //child process server

{

readfd = open("/tmp/fifo.1", O_RDONLY, 0);

r_length=read(readfd,buffer,MAX_LENGTH);

printf("r_length===%d/n",r_length);

printf("buffer===%s/n",buffer);

printf("buffer===%d/n",strlen(buffer));

close(readfd);

}

else

{

writefd=open("/tmp/fifo.1", O_WRONLY, 0);

w_length=write(writefd,"abcdef",11);

printf("w_length===%d/n",w_length);

waitpid(childpid, NULL, 0);

close(writefd);

unlink("/tmp/fifo.1");

}

# gcc simplefifo.c -lpthread -o simplefifo

Ø norelationsprocessfifo

没有亲缘关系的进程之间使用一个FIFO。将其中阻塞的进程称为服务端进程，将另一个称为客户端进程。客户端向FIFO写数据，服务端从FIFO读取数据。

// norelationsprocessfifo_server.c

#include <sys/types.h>

#include <sys/stat.h> //mkfifo

#include <errno.h> // errno

#include <fcntl.h> //O_RDONLY

int main(int argc, char **argv)

{

int readfd;

int r_length;

char buffer[10];

if ((mkfifo("/tmp/fifo.1", (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))<0) && (errno == EEXIST))

printf("can't create %s", "/tmp/fifo.1");

printf("befor open fifo/n");

readfd = open("/tmp/fifo.1", O_RDONLY, 0);

printf("have open and befor read/n");

r_length=read(readfd,buffer,10);

printf("have read and r_length=%d;strlen(buffer)=%d;buffer=%s;/n",r_length,strlen(buffer),buffer);

close(readfd);

}

//#gcc norelationsprocessfifo_server.c –o norelationsprocessfifo_server

// norelationsprocessfifo_client.c

#include <sys/types.h>

#include <sys/stat.h> //mkfifo

#include <fcntl.h> //O_RDONLY

int main(int argc, char **argv)

{

int writefd;

int w_length;

printf("befor open fifo/n");

sleep(5);

writefd=open("/tmp/fifo.1", O_WRONLY, 0);

printf("fifo have open and befor write/n");

sleep(5);

w_length=write(writefd,"abcdef",11);

printf("have write/n");

sleep(5);

close(writefd);

unlink("/tmp/fifo.1");

}

//#gcc norelationsprocessfifo_client.c –o norelationsprocessfifo_client

服务端创建FIFO，并阻塞（等待客户端打开FIFO写文件描述字）打开FIFO读文件描述字，然后阻塞（等待客户端向FIFO的写文件描述字写进数据）从FIFO读文件描述字中读取数据，最后关闭读文件描述字。

客户端打开FIFO的写文件描述字，然后向FIFO写文件描述字中写进数据，然后关闭写文件描述字，最后删除FIFO。

通过程序的输出可以很明显的看出阻塞过程，其中方框中输出对应的服务端open和read函数即为阻塞点，示意图如下：

阻塞输出示意图

阻塞发生在服务端，因此只需要在服务端以非阻塞方式（O_NONBLOCK）打开FIFO的读文件描述字，则open函数和read函数均以非阻塞方式执行。

//norelationsprocessfifo_noblock_server.c

#include <sys/types.h>

#include <sys/stat.h> //mkfifo

#include <errno.h> // errno

#include <fcntl.h> //O_RDONLY

int main(int argc, char **argv)

{

int readfd;

int r_length;

char buffer[10];

if ((mkfifo("/tmp/fifo.1", (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))<0) && (errno != EEXIST))

printf("can't create %s", "/tmp/fifo.1");

printf("befor open fifo/n");

readfd = open("/tmp/fifo.1", O_RDONLY|O_NONBLOCK, 0);

printf("have open and befor read/n");

int p=0;

while(1)

{

r_length=read(readfd,buffer,10);

printf("%d/n",p++);

if(r_length>0)

{

printf("have read and r_length=%d;strlen(buffer)=%d;buffer=%s;/n",r_length,strlen(buffer),buffer);

sleep(3);

}

close(readfd);

}

//#gcc norelationsprocessfifo_noblock_server.c –o noblockserver

由于read函数也不发生阻塞，因此必须有一个无限循环等待客户端发送数据。

norelationsprocessfifo_noblock_client.c代码和norelationsprocessfifo_client.c相同。

Ø structmesg

进程之间可以通过FIFO传递struct变量数据。

//structmesg.h

#include <sys/types.h>

#include <sys/stat.h> //mkfifo

#include <fcntl.h> //O_RDONLY

#include <limits.h> /* PIPE_BUF */

#define MAXMESGDATA (PIPE_BUF - 2*sizeof(long))

#define MESGHDRSIZE (sizeof(struct mymesg) - MAXMESGDATA)

struct mymesg {

long mesg_len; /* #bytes in mesg_data, can be 0 */

long mesg_type; /* message type, must be > 0 */

char mesg_data[MAXMESGDATA];

};

//structmesg_server.c

#include <errno.h>

#include "structmesg.h"

int main(int argc, char **argv)

{

int readfd;

size_t len;

ssize_t n;

struct mymesg mesg;

if ((mkfifo("/tmp/fifo.1", (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))<0) && (errno == EEXIST))

printf("can't create %s", "/tmp/fifo.1");

readfd = open("/tmp/fifo.1", O_RDONLY, 0);

if ( (n = read(readfd, &mesg, MESGHDRSIZE)) == 0)

//第一次读取固定长度数据，得到数据类型和结构体数据长度

{

printf("end of file!/n"); //到达文件的末尾，没有数据

return(0); /* end of file */

}

else if (n != MESGHDRSIZE)

{

printf("message header: expected %d, got %d", MESGHDRSIZE, n); //数据有误，长度不一致

return(0);

}

if ( (len = mesg.mesg_len) > 0)//结构体中有具体的数据，长度不为0

if ( (n = read(readfd, mesg.mesg_data, len)) != len)

//第二次读取具体的结构体数据

{

printf("message data: expected %d, got %d", len, n);//数据有误，长度不一致

return(0);

}

printf("mesg_len=%d/tmesg_type=%d/tmesg_data=%s/n",mesg.mesg_len,mesg.mesg_type,mesg.mesg_data);

close(readfd);

return 0;

}

注意判断各种可能的情况。第一次读取结构体数据长度和类型是用struct mymesg指针作为入参，那么只填充了前面两个成员变量，这可以从struct的存储结构来理解；第二次读取是以struct mymesg的成员mesg_data作为入参。

#include "structmesg.h"

int main(int argc, char **argv)

{

int writefd;

struct mymesg mesg;

writefd = open("/tmp/fifo.1", O_WRONLY, 0);

mesg.mesg_len=10;

mesg.mesg_type=1;

strcpy(mesg.mesg_data,"abcdefghij");

write(writefd,&mesg,MESGHDRSIZE+mesg.mesg_len);

close(writefd);

unlink("/tmp/fifo.1");

}

3、小结

Ø pipe(管道)没有名称，因此只能在父子进程之间使用（不考虑传递文件描述字的情况）；

而FIFO(具名管道)有名称，因此可以在非亲缘关系进程之间使用。

Ø FIFO是一种只能在单台主机上使用的IPC(进程间通信)形式。尽管在文件系统中有名

字，它们也只能用在本地文件系统中，而不能用在通过NFS安装的文件系统中。

Ø 创建pipe和获得管道的文件描述字只需要pipe(int fd[2])函数，而mkfifo创建FIFO，open

获得文件描述字。

关闭pipe的文件描述字以后，pipe就自动消失了，而对于FIFO，不仅要关闭其文件描述字，还要调用unlink函数来彻底删除。

Ø 任意时刻打开管道和FIFO描述字的数目是有一定限制的；

管道和FIFO的write操作的原子性的前提是数据量小于PIPE_BUF，在一次写操作过程中数据量小于PIPE_BUF时，写操作原子性能够保证；

数据是面向字节流的，也就是从管道/FIFO一端读出的100个字节，另一端可能1次write100个字节，可能2次50个字节，可能5次20个字节。也就是无法区别对端一次性write的数据量。

针对管道/FIFO数据字节流的特点，在两端必须由应用自定义解释，也就是编制数据传输的协议。

Ø FIFO和pipe一样可以以全双工的形式来使用，原理也是一个进程同时打开读和写的文

件描述字，但全双工使用较少，尽量采用半双工形式。

分享到：

IPC SystemV Message Queue | IPC PIPE

2010-12-25 20:32
浏览 275
评论(0)
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

IPC FIFO

FIFO

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

IPC FIFO

FIFO

评论

发表评论

相关推荐

最近访客更多访客>>