fd = open("/etc/service", O_RDONLY | O_NONBLOCK);

 /* if error */

 while () {

     size = read(fd, buf, BUFSIZE);

     if (size < ) {

         if (EAGAIN == errno) {

             continue;

         }

         perror("read()");

         exit();

     }

     // do sth...

 }

 #include <stdio.h>

 #include <stdlib.h>

 #include <unistd.h>

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <fcntl.h>

 #include <errno.h>

 #define BUFSIZE        1024

 #define TTY1        "/dev/tty11"

 #define TTY2        "/dev/tty12"

 /* 状态机的各种状态 */

 enum

 {

     STATE_R=,

     STATE_W,

     STATE_Ex,

     STATE_T

 };

 /* 状态机，根据不同的需求设计不同的成员 */

 struct fsm_st

 {

     int state; // 状态机当前的状态

     int sfd; // 读取的来源文件描述符

     int dfd; // 写入的目标文件描述符

     char buf[BUFSIZE]; // 缓冲

     int len; // 一次读取到的实际数据量

     int pos; // buf 的偏移量，用于记录坚持写够 n 个字节时每次循环写到了哪里

     char *errstr; // 错误消息

 };

 /* 状态机驱动 */

 static void fsm_driver(struct fsm_st *fsm)

 {

     int ret;

     switch(fsm->state)

     {

         case STATE_R: // 读态

             fsm->len = read(fsm->sfd,fsm->buf,BUFSIZE);

             if(fsm->len == ) // 读到了文件末尾，将状态机推向 T态

                 fsm->state = STATE_T;

             else if(fsm->len < ) // 读取出现异常

             {

                 if(errno == EAGAIN) // 如果是假错就推到 读态，重新读一次

                     fsm->state = STATE_R;

                 else // 如果是真错就推到 异常态

                 {

                     fsm->errstr = "read()";

                     fsm->state = STATE_Ex;

                 }

             }

             else // 成功读取到了数据，将状态机推到 写态

             {

                 fsm->pos = ;

                 fsm->state = STATE_W;

             }

             break;

         case STATE_W: // 写态

             ret = write(fsm->dfd,fsm->buf+fsm->pos,fsm->len);

             if(ret < ) // 写入出现异常

             {

                 if(errno == EAGAIN) // 如果是假错就再次推到 写态，重新再写入一次

                     fsm->state = STATE_W;

                 else // 如果是真错就推到 异常态

                 {

                     fsm->errstr = "write()";

                     fsm->state = STATE_Ex;

                 }

             }

             else // 成功写入了数据

             {

                 fsm->pos += ret;

                 fsm->len -= ret;

                 if(fsm->len == ) // 如果将读到的数据完全写出去了就将状态机推向 读态，开始下一轮读取

                     fsm->state = STATE_R;

                 else // 如果没有将读到的数据完全写出去，那么状态机依然推到 写态，下次继续写入没写完的数据，实现“坚持写够 n 个字节”

                     fsm->state = STATE_W;

             }

             break;

         case STATE_Ex: // 异常态，打印异常并将状态机推到 T态

             perror(fsm->errstr);

             fsm->state = STATE_T;

             break;

         case STATE_T: // 结束态，在这个例子中结束态没有什么需要做的事情，所以空着

             /*do sth */

             break;

         default: // 程序很可能发生了溢出等不可预料的情况，为了避免异常扩大直接自杀

             abort();

     }

 }

 /* 推动状态机 */

 static void relay(int fd1,int fd2)

 {

     int fd1_save,fd2_save;

     // 因为是读 tty1 写 tty2；读 tty2 写 tty1，所以这里的两个状态机直接取名为 fsm12 和 fsm21

     struct fsm_st fsm12,fsm21;

     fd1_save = fcntl(fd1,F_GETFL);

     // 使用状态机操作 IO 一般都采用非阻塞的形式，避免状态机被阻塞

     fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);

     fd2_save = fcntl(fd2,F_GETFL);

     fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);

     // 在启动状态机之前将状态机推向 读态

     fsm12.state = STATE_R;

     // 设置状态机中读写的来源和目标，这样状态机的读写接口就统一了。在状态机里面不用管到底是 读tty1 写tty2 还是 读tty2 写tty1 了，它只需要知道是 读src 写des 就可以了。

     fsm12.sfd = fd1;

     fsm12.dfd = fd2;

     // 同上

     fsm21.state = STATE_R;

     fsm21.sfd = fd2;

     fsm21.dfd = fd1;

     // 开始推状态机，只要不是 T态 就一直推

     while(fsm12.state != STATE_T || fsm21.state != STATE_T)

     {

         // 调用状态机驱动函数，状态机开始工作

         fsm_driver(&fsm12);

         fsm_driver(&fsm21);

     }

     fcntl(fd1,F_SETFL,fd1_save);

     fcntl(fd2,F_SETFL,fd2_save);

 }

 int main()

 {

     int fd1,fd2;

     // 假设这里忘记将设备 tty1 以非阻塞的形式打开也没关系，因为推动状态机之前会重新设定文件描述符为非阻塞形式

     fd1 = open(TTY1,O_RDWR);

     if(fd1 < )

     {

         perror("open()");

         exit();

     }

     write(fd1,"TTY1\n",);

     fd2 = open(TTY2,O_RDWR|O_NONBLOCK);

     if(fd2 < )

     {

         perror("open()");

         exit();

     }

     write(fd2,"TTY2\n",);

     relay(fd1,fd2);

     close(fd1);

     close(fd2);

     exit();

 }

 select,  FD_CLR,  FD_ISSET, FD_SET, FD_ZERO - synchronous I/O multiplexing

 /* According to POSIX.1-2001 */

 #include <sys/select.h>

 /* According to earlier standards */

 #include <sys/time.h>

 #include <sys/types.h>

 #include <unistd.h>

 int select(int nfds, fd_set *readfds, fd_set *writefds,

            fd_set *exceptfds, struct timeval *timeout);

 void FD_CLR(int fd, fd_set *set);

 int  FD_ISSET(int fd, fd_set *set);

 void FD_SET(int fd, fd_set *set);

 void FD_ZERO(fd_set *set);

 enum

 {

     STATE_R=,

     STATE_W,

 STATE_AUTO, // 添加这个值是为了起到分水岭的作用，小于这个值的时候才需要使用 select(2) 监视

     STATE_Ex,

     STATE_T

 };

 static int max(int a,int b)

 {

     if(a < b)

         return b;

     return a;

 }

 static void relay(int fd1,int fd2)

 {

     int fd1_save,fd2_save;

     struct fsm_st fsm12,fsm21;

     fd_set rset,wset; // 读写文件描述符集合

     fd1_save = fcntl(fd1,F_GETFL);

     fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);

     fd2_save = fcntl(fd2,F_GETFL);

     fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);

     fsm12.state = STATE_R;

     fsm12.sfd = fd1;

     fsm12.dfd = fd2;

     fsm21.state = STATE_R;

     fsm21.sfd = fd2;

     fsm21.dfd = fd1;

     while(fsm12.state != STATE_T || fsm21.state != STATE_T)

     {

         //布置监视任务

         FD_ZERO(&rset);

         FD_ZERO(&wset);

         // 读态监视输入文件描述符；写态监视输出文件描述符

         if(fsm12.state == STATE_R)

             FD_SET(fsm12.sfd,&rset);

         if(fsm12.state == STATE_W)

             FD_SET(fsm12.dfd,&wset);

         if(fsm21.state == STATE_R)

             FD_SET(fsm21.sfd,&rset);

         if(fsm21.state == STATE_W)

             FD_SET(fsm21.dfd,&wset);

         if(fsm12.state < STATE_AUTO || fsm21.state < STATE_AUTO)

         {

             // 以阻塞形式监视

             if(select(max(fd1,fd2)+,&rset,&wset,NULL,NULL) < )

             {

                 if(errno == EINTR)

                     continue;

                 perror("select()");

                 exit();

             }

         }

         //查看监视结果

         if( FD_ISSET(fd1,&rset) || FD_ISSET(fd2,&wset) || fsm12.state > STATE_AUTO)

             fsm_driver(&fsm12);

         if( FD_ISSET(fd2,&rset) || FD_ISSET(fd1,&wset) || fsm21.state > STATE_AUTO)

             fsm_driver(&fsm21);

     }

     fcntl(fd1,F_SETFL,fd1_save);

     fcntl(fd2,F_SETFL,fd2_save);

 }

 poll - wait for some event on a file descriptor

 #include <poll.h>

 int poll(struct pollfd *fds, nfds_t nfds, int timeout);

 struct pollfd {

     int   fd;         /* 需要监视的文件描述符 */

     short events;     /* 要监视的事件 */

     short revents;    /* 该文件描述符发生了的事件 */

 };

 static void relay(int fd1,int fd2)

 {

     int fd1_save,fd2_save;

     struct fsm_st fsm12,fsm21;

     struct pollfd pfd[]; // 一共监视两个文件描述符

     fd1_save = fcntl(fd1,F_GETFL);

     fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);

     fd2_save = fcntl(fd2,F_GETFL);

     fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);

     fsm12.state = STATE_R;

     fsm12.sfd = fd1;

     fsm12.dfd = fd2;

     fsm21.state = STATE_R;

     fsm21.sfd = fd2;

     fsm21.dfd = fd1;

     pfd[].fd = fd1;

     pfd[].fd = fd2;

     while(fsm12.state != STATE_T || fsm21.state != STATE_T)

     {

         // 布置监视任务

         pfd[].events = ;

         if(fsm12.state == STATE_R)

             pfd[].events |= POLLIN; // 第一个文件描述符可读

         if(fsm21.state == STATE_W)

             pfd[].events |= POLLOUT; // 第一个文件描述符可写

         pfd[].events = ;

         if(fsm12.state == STATE_W)

             pfd[].events |= POLLOUT; // 第二个文件描述符可读

         if(fsm21.state == STATE_R)

             pfd[].events |= POLLIN; // 第二个文件描述符可写

         // 只要是可读写状态就进行监视

         if(fsm12.state < STATE_AUTO || fsm21.state < STATE_AUTO)

         {

             // 阻塞监视

             while(poll(pfd,,-) < )

             {

                 if(errno == EINTR)

                     continue;

                 perror("poll()");

                 exit();

             }

         }

         // 查看监视结果

         if( pfd[].revents & POLLIN || \

             pfd[].revents & POLLOUT || \

             fsm12.state > STATE_AUTO)

             fsm_driver(&fsm12); // 推状态机

         if( pfd[].revents & POLLIN || \

             pfd[].revents & POLLOUT || \

             fsm21.state > STATE_AUTO)

             fsm_driver(&fsm21); // 推状态机

     }

     fcntl(fd1,F_SETFL,fd1_save);

     fcntl(fd2,F_SETFL,fd2_save);

 }

 epoll_create - open an epoll file descriptor

 #include <sys/epoll.h>

 int epoll_create(int size);

 epoll_ctl - control interface for an epoll descriptor

 #include <sys/epoll.h>

 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

 struct epoll_event {

        uint32_t events; /* Epoll 监视的事件，这些事件与 poll(2) 能监视的事件差不多，只是宏名前面加了个E */

        epoll_data_t data; /* 用户数据，除了能保存文件描述符以外，还能让你保存一些其它有关数据，比如你这个文件描述符是嵌在一棵树上的，你在使用它的时候不知道它是树的哪个节点，则可以在布置监视任务的时候将相关的位置都保存下来。这个联合体成员就是 epoll 设计的精髓。 */

 };

 epoll_wait  -  wait  for  an  I/O  event on an epoll file descriptor

 #include <sys/epoll.h>

 int epoll_wait(int epfd, struct epoll_event *events,

                int maxevents, int timeout);

 static void relay(int fd1,int fd2)

 {

     int fd1_save,fd2_save;

     struct fsm_st fsm12,fsm21;

     int epfd;

     struct epoll_event ev;

     epfd = epoll_create();

     if(epfd < )

     {

         perror("epfd()");

         exit();

     }

     fd1_save = fcntl(fd1,F_GETFL);

     fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);

     fd2_save = fcntl(fd2,F_GETFL);

     fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);

     fsm12.state = STATE_R;

     fsm12.sfd = fd1;

     fsm12.dfd = fd2;

     fsm21.state = STATE_R;

     fsm21.sfd = fd2;

     fsm21.dfd = fd1;

     ev.events = ;

     ev.data.fd = fd1;

     epoll_ctl(epfd,EPOLL_CTL_ADD,fd1,&ev);

     ev.events = ;

         ev.data.fd = fd2;

         epoll_ctl(epfd,EPOLL_CTL_ADD,fd2,&ev);

     while(fsm12.state != STATE_T || fsm21.state != STATE_T)

     {

         // 布置监视任务

         ev.events = ;

         ev.data.fd = fd1;

         if(fsm12.state == STATE_R)

             ev.events |= EPOLLIN;

         if(fsm21.state == STATE_W)

             ev.events |= EPOLLOUT;

         epoll_ctl(epfd,EPOLL_CTL_MOD,fd1,&ev);

         ev.events = ;

         ev.data.fd = fd2;

         if(fsm12.state == STATE_W)

             ev.events |= EPOLLOUT;

         if(fsm21.state == STATE_R)

             ev.events |= EPOLLIN;

         epoll_ctl(epfd,EPOLL_CTL_MOD,fd2,&ev);

         // 监视

         if(fsm12.state < STATE_AUTO || fsm21.state < STATE_AUTO)

         {

             while(epoll_wait(epfd,&ev,,-) < )

             {

                 if(errno == EINTR)

                     continue;

                 perror("epoll_wait()");

                 exit();

             }

         }

         // 查看监视结果

         if( ev.data.fd == fd1 && ev.events & EPOLLIN || \

             ev.data.fd == fd2 && ev.events & EPOLLOUT || \

             fsm12.state > STATE_AUTO)

             fsm_driver(&fsm12);

         if( ev.data.fd == fd2 && ev.events & EPOLLIN || \

             ev.data.fd == fd1 && ev.events & EPOLLOUT  || \

             fsm21.state > STATE_AUTO)

             fsm_driver(&fsm21);

     }

     fcntl(fd1,F_SETFL,fd1_save);

     fcntl(fd2,F_SETFL,fd2_save);

     close(epfd);

 }

 readv,  writev  -  read  or write data into multiple buffers

 #include <sys/uio.h>

 ssize_t readv(int fd, const struct iovec *iov, int iovcnt);

 ssize_t writev(int fd, const struct iovec *iov, int iovcnt);

 struct iovec {

         void  *iov_base;    /* 起始地址 */

         size_t iov_len;     /* Number of bytes to transfer */

 };

 mmap, munmap - map or unmap files or devices into memory

 #include <sys/mman.h>

 void *mmap(void *addr, size_t length, int prot, int flags,

            int fd, off_t offset);

 int munmap(void *addr, size_t length);

 #include <stdio.h>

 #include <stdlib.h>

 #include <sys/mman.h>

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <unistd.h>

 #include <fcntl.h>

 #define FNAME        "/etc/services"

 int main(void)

 {

     int fd,i;

     char *str;

     struct stat statres;

     int count = ;

     fd = open(FNAME,O_RDONLY);

     if(fd < )

     {

         perror("open()");

         exit();

     }

     // 通过 stat(2) 获得文件大小

     if(fstat(fd,&statres) < )

     {

         perror("fstat()");

         exit();

     }

     str = mmap(NULL,statres.st_size,PROT_READ,MAP_SHARED,fd,);

     if(str == MAP_FAILED)

     {

         perror("mmap()");

         exit();

     }

     // 将文件映射到内存之后文件描述符就可以关闭了，直接访问映射的内存就相当于访问文件了。

     close(fd);

     for(i =  ; i < statres.st_size; i++) {

         // 因为访问的是文本文件，所以可以把映射的内存看作是一个大字符串处理

         if(str[i] == 'a') {

             count++;

         }

     }

     printf("count = %d\n",count);

     // 用完了别忘了解除映射，不然会造成内存泄漏！

     munmap(str,statres.st_size);

     exit();

 }

 #include <stdio.h>

 #include <stdlib.h>

 #include <sys/mman.h>

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <unistd.h>

 #include <fcntl.h>

 #include <string.h>

 #include <wait.h>

 #define MEMSIZE        1024

 int main(void)

 {

     char *str;

     pid_t pid;

     // 这里在 flags 中添加 MAP_ANONYMOUS，为制作共享内存做准备

     str = mmap(NULL,MEMSIZE,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-,);

     if(str == MAP_FAILED)

     {

         perror("mmap()");

         exit();

     }

     // 创建子进程，父子进程使用共享内存进行通信

     pid = fork();

     if(pid < )

     {

         perror("fork()");

         exit();

     }

     if(pid == ) // 子进程向共享内存中写入数据

     {

         strcpy(str,"Hello!");

         munmap(str,MEMSIZE); // 注意，虽然共享内存是在 fork(2) 之前创建的，但是 fork(2) 的时候子进程也拷贝了一份，所以子进程使用完毕之后也要解除映射

         exit();

     }

     else // 父进程从共享内存中读取子进程写入的数据

     {

         wait(NULL); // 保障子进程先运行起来，因为就算父进程先运行了也会在这里阻塞等待

         puts(str); // 把从共享内存中读取出来的数据打印出来

         munmap(str,MEMSIZE); // 不要忘记解除映射

         exit();

     }

     exit();

 }

 lockf - apply, test or remove a POSIX lock on an open file

 #include <unistd.h>

 int lockf(int fd, int cmd, off_t len);

 flock - apply or remove an advisory lock on an open file

 #include <sys/file.h>

 int flock(int fd, int operation);

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

 #include <unistd.h>

 #include <wait.h>

 #include <sys/types.h>

 #define PROCNUM        20

 #define FNAME        "/tmp/out"

 #define BUFSIZE        1024

 static void func_add()

 {

     FILE *fp;

     int fd;

     char buf[BUFSIZE];

     fp = fopen(FNAME,"r+");

     if(fp == NULL)

     {

         perror("fopen()");

         exit();

     }

     fd = fileno(fp);

     if(fd < )

     {

         perror("fd");

         exit();

     }

     // 使用之前先锁定

     lockf(fd,F_LOCK,);

     fgets(buf,BUFSIZE,fp);

     rewind(fp); // 把文件位置指针定位到文件首

     sleep(); // 放大竞争

     fprintf(fp,"%d\n",atoi(buf)+);

     fflush(fp);

     // 使用之后释放锁

     lockf(fd,F_ULOCK,);

     fclose(fp);

     return ;

 }

 int main(void)

 {

     int i;

     pid_t pid;

     for(i =  ; i < PROCNUM ; i++)

     {

         pid = fork();

         if(pid < )

         {

             perror("fork()");

             exit();

         }

         if(pid == )    // child

         {

             func_add();

             exit();

         }

     }

     for(i =  ; i < PROCNUM ; i++)

         wait(NULL);

     exit();

 }