目录

1. 阻塞和非阻塞 IO

2. IO 多路转接（select、poll、epoll）

3. 存储映射 IO（mmap）

4. 文件锁（fcntl、lockf、flock）

5. 管道实例 - 池类算法

1. 阻塞和非阻塞 IO

• 阻塞 IO：会等待操作的完成或期待事情的到来。会被信号打断（信号会打断阻塞中的系统调用），若被打断则错误码为 EINTR（假错）。操作的完成和期待事件的到来会通知阻塞的进程。

• 非阻塞 IO：若操作未完成或期待的事情还没到来，则立即返回，不会等待。若未发生期待事件则返回错误码 EAGAIN（假错）。不会通知，但可以通过轮询查看状态。

有限状态机编程例子，中继引擎实现，实现不同 tty 设备之间的中继引擎，实现 tty 之间相互通信，但是是忙等（因为没有使用阻塞 IO，没有用到同步手段）：

1-io/advio/nonblock/relayer

2. IO 多路转接（select、poll、epoll）

上述有限状态机例子是 I/O 密集型任务，可以使用 IO 多路转接。 

IO 多路转接：监视文件描述符的行为，当当前文件描述符发生了期待的行为的时候，才去执行后续的操作。可以监视多个文件描述符。

1. select() 可以用来监视多个文件描述符，包括可读、可写、异常文件描述符，移植性很好，比较古老，传参不稳定。以事件为单位来组织文件描述符。监视期间会阻塞，也会被信号打断（假错）。

#include <sys/select.h>
 
int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);
 
// 删除指定的fd
void FD_CLR(int fd, fd_set *set);
// 判断fd是否在集合中
int  FD_ISSET(int fd, fd_set *set);
// 将fd加入到集合中
void FD_SET(int fd, fd_set *set);
// 清空集合
void FD_ZERO(fd_set *set);

缺点：

• 监视内容和监视结果存放在同一处 readfds、writefds、exceptfds。 

• 文件描述符有大小限制。

2. poll() 可以等待在文件描述上发生的特定事件，以文件描述符为单位来组织事件。把期待的事件 events 和已经发生的事件 revents 区分开来了，可以移植。

#include <poll.h>
 
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
 
struct pollfd {
    int   fd;         /* file descriptor */
    short events;     /* requested events */
    short revents;    /* returned events */
};

如果将 timeout 设置为 0 即为非阻塞，-1 表示为阻塞。跳过 pollfd 结构体中的 events 来指定特定的期待事件。

3. epoll()，linux 基于 poll 来做的一些优化版本，不可移植。

#include <sys/epoll.h>
 
// 打开一个epoll文件描述符
int epoll_create(int size);
int epoll_create1(int flags);
 
// 控制epoll文件描述符
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
 
// 等待epoll文件描述符上的事件
int epoll_wait(int epfd, struct epoll_event *events,
               int maxevents, int timeout);
int epoll_pwait(int epfd, struct epoll_event *events,
                int maxevents, int timeout,
                const sigset_t *sigmask);

3. 存储映射 IO（mmap）

可以使用 readv(2) 和 writev(2) 来将读写多个碎片 buffer。

#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);

存储映射 IO 可以将某一块内存，或者某一个文件的内容映射到当前进程空间中。

1. mmap(2) 可以将文件或者设备映射到内存中，返回映射区域的起始地址。

#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);

参数： 

• addr： 指定映射的虚拟内存地址，若为 NULL 则由内核选择合适的虚拟内存地址；

• length：映射的长度；

• prot：映射内存的保护模式，可选值如下：

  PROT_EXEC：可以被执行；

  PROT_READ：可以被读取；

  PROT_WRITE：可以被写入；

  PROT_NONE：不可访问；

• flags：指定映射的类型，可选值如下：

  MAP_FIXED：使用指定的起始虚拟内存地址进行映射；

  MAP_SHARED：与其他所有映射到这个文件的进程共享映射空间（可实现共享内存）；

  MAP_PRIVATE：建立一个写时复制（copy-on-write）的私有映射空间；

  MAP_ANONYMOUS：匿名映射，可以替代 malloc，不依赖于任何文件，并且当前空间被  初始化为 0；

  .....

• fd：进行映射的文件描述符；

• offset：文件偏移量（从文件何处开始映射）；

例子1，mmap.c，使用 mmap 打开文件，并且计算文件中 a 字符出现的次数：

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
int main(int argc, char *argv[])
{
  if (argc < 2)
  {
    fprintf(stderr, "Usage..\n");
    exit(1);
  }
 
  int fd;
  void *addr;
  char *p;
  struct stat statbuf;
  int anum = 0;
  if ((fd = open(argv[1], O_RDONLY)) < 0)
  {
    perror("open");
    exit(1);
  }
 
  if (fstat(fd, &statbuf) < 0)
  {
    perror("fstat");
    exit(1);
  }
 
  addr = mmap(NULL, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
  if (addr == MAP_FAILED)
  {
    perror("mmap()");
    exit(1);
  }
 
  p = (char *)addr;
  for (int i = 0; i < statbuf.st_size; i++)
  {
    if (*(p + i) == 'a')
    {
      anum++;
    }
  }
  munmap(addr, statbuf.st_size);
 
  printf("the number of a in the file is: %d\n", anum);
  exit(0);
}

mmap 还能实现共享内存，从而实现有亲缘关系的进程间的通信。比如父进程先 mmap，然后再 fork，这样子进程也能访问父进程 mmap 出来的空间（flags 为 MAP_SHARED 和 MAP_ANONYMOUS）。

例子，share_mem.c，使用 mmap 实现父子进程间的共享内存（子进程写入 hello，父进程打印）：

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
 
#define MEMSIZE 1024
 
int main()
{
  int fd;
  pid_t pid;
  char *addr;
  addr = (char *)mmap(NULL, MEMSIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
  if (addr == MAP_FAILED)
  {
    perror("mmap");
    exit(1);
  }
 
  pid = fork();
  if (pid < 0)
  {
    perror("fork");
    exit(1);
  }
 
  if (pid == 0) // child
  {
    strcpy(addr, "Hello!");
    munmap(addr, MEMSIZE);
    exit(0);
  }
  else // parent
  {
    wait(NULL);
    puts(addr);
    munmap(addr, MEMSIZE);
    exit(0);
  }
}

4. 文件锁（fcntl、lockf、flock）

对文件加锁是在 inode 结构体上进行的，如果对一个文件描述符进行了 dup 或者重新 open 了新的文件描述符，对不同的文件描述符加锁和解锁都是作用于同一个 inode 的。 有如下几种文件加锁方法：

fcntl() 前面讲过。Linux系统编程（二）文件IO/系统调用IO-CSDN博客

lockf() 可以对文件进行加锁或者解锁，在 linux 上 lockf 就是 fcntl 的封装。

#include <unistd.h>
 
int lockf(int fd, int cmd, off_t len);

flock() 可以给打开的文件加上或移除咨询锁（advisory lock）。

#include <sys/file.h>
 
int flock(int fd, int operation);

5. 管道实例 - 池类算法

例子：4-parallel/thread/mypipe。

Linux系统编程（李慧琴）: Linux系统编程（李慧琴）学习代码及笔记