文件IO之——阻塞和非阻塞及perror函数

读常规文件是不会阻塞的,不管读多少字节,read一定会在有限的时间内返回。从终端
设备或网络读则不一定,如果从终端输入的数据没有换行符,调用read读终端设备就会阻
塞,如果网络上没有接收到数据包,调用read从网络读就会阻塞,至于会阻塞多长时间也是
不确定的,如果一直没有数据到达就一直阻塞在那里。同样,写常规文件是不会阻塞的,而
向终端设备或网络写则不一定。
现在明确一下阻塞(Block)这个概念。当进程调用一个阻塞的系统函数时,该进程被
置于睡眠(Sleep)状态,这时内核调度其它进程运行,直到该进程等待的事件发生了(比
如网络上接收到数据包,或者调用sleep指定的睡眠时间到了)它才有可能继续运行。与睡
眠状态相对的是运行(Running)状态,在Linux内核中,处于运行状态的进程分为两种情
况:
正在被调度执行。CPU处于该进程的上下文环境中,程序计数器(eip)里保存着该进程
的指令地址,通用寄存器里保存着该进程运算过程的中间结果,正在执行该进程的指令,正
在读写该进程的地址空间。
就绪状态。该进程不需要等待什么事件发生,随时都可以执行,但CPU暂时还在执行另
一个进程,所以该进程在一个就绪队列中等待被内核调度。系统中可能同时有多个就绪的进
程,那么该调度谁执行呢?内核的调度算法是基于优先级和时间片的,而且会根据每个进程
的运行情况动态调整它的优先级和时间片,让每个进程都能比较公平地得到机会执行,同时
要兼顾用户体验,不能让和用户交互的进程响应太慢。

阻塞读终端：

#include <unistd.h>
#include <stdlib.h>
#include<stdio.h>
#include<errno.h>
int main(void)
{
  char buf[10];
  int n;
  n = read(STDIN_FILENO, buf, 10);
  if (n < 0) {
    perror("read STDIN_FILENO");
    exit(1);
    }
  write(STDOUT_FILENO, buf, n);
  return 0;
}

第一次执行app的结果很正常,而第二次执行的过程有点特殊,现在分析一下:
Shell进程创建app进程,app进程开始执行,而Shell进程睡眠等待app进程退
出。
app调用read时睡眠等待,直到终端设备输入了换行符才从read返回,read只读走10
个字符,剩下的字符仍然保存在内核的终端设备输入缓冲区中。
a.out进程打印并退出,这时Shell进程恢复运行,Shell继续从终端读取用户输入的命
令,于是读走了终端设备输入缓冲区中剩下的字符d和换行符,把它当成一条命令解释执
行,结果发现执行不了,没有d这个命令。(这是由于我们的缓冲区只定义了10个长度，超出长度了，当shell进程恢复时，会调用溢出的数据)。

如果在open一个设备时指定了O_NONBLOCK标志,read/write就不会阻塞。以read为例,
如果设备暂时没有数据可读就返回-1,同时置errno为EWOULDBLOCK(或者EAGAIN,这两个
宏定义的值相同),表示本来应该阻塞在这里(would block,虚拟语气),事实上并没
有阻塞而是直接返回错误,调用者应该试着再读一次(again)。这种行为方式称为轮询
(Poll),调用者只是查询一下,而不是阻塞在这里死等,这样可以同时监视多个设备:

如果read(设备1)是阻塞的,那么只要设备1没有数据到达就会一直阻塞在设备1的read
调用上,即使设备2有数据到达也不能处理,使用非阻塞I/O就可以避免设备2得不到及时处
理。
非阻塞I/O有一个缺点,如果所有设备都一直没有数据到达,调用者需要反复查询做无
用功,如果阻塞在那里,操作系统可以调度别的进程执行,就不会做无用功了。

以后要学习的select(2)函数可以阻塞地同时监视多个设
备,还可以设定阻塞等待的超时时间,从而圆满地解决了这个问题。
以下是一个非阻塞I/O的例子。目前我们学过的可能引起阻塞的设备只有终端,所以我
们用终端来做这个实验。程序开始执行时在0、1、2文件描述符上自动打开的文件就是终
端,但是没有O_NONBLOCK标志。所以就像上面例子 “阻塞读终端”一样,读标准输入是阻塞
的。我们可以重新打开一遍设备文件/dev/tty(表示当前终端),在打开时指定O_NONBLOCK
标志。

perror（）函数，不仅可以打印错误信息，还会提示更多信息，会设置全局变量errno的值，根据这个全局变量的值，打印出错误信息。

#include <unistd.h>
#include <stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<sys/types.h>
int main(void)
{
  int fd=open("virtul_file",O_WRONLY);
  if(fd<0)
  {
    printf("errno=%d
",errno);
    perror("***#yangguang#***");
  }
  printf("fd=%d
",fd);
  return 0;
}

先创建好文件virtul_file，只给读权限，但是程序我们却以只写的方式打开：

这样，perror打印出权限不够。我们想知道，这个errno全局变量的值13代表什么，那么查询头文件<errno.h>，一般来说，系统头文件在/usr/include下面。

使用find命令查找头文件，打开第一个文件：

发现还包含了一个头文件，并且宏定义的值从35开始的，我们之前的errno是13，故猜测应该在这个包含的头文件中：

打开这个头文件：

果然，如我们所期，请看宏定义EACCES，它的值为13，并且显示 Permission denied   (权限不够)。

看来，linux是通过操作这些宏，并把这些宏赋值给全局变量errno，通过errno的值，perror函数打印出不同的错误信息。要使用errno这个全局变量，需要包含头文件#include <errno.h>。

说到perror函数就不得不说一下

#include <string.h>

char *strerror(int errnum);

 strerror函数，它的参数用全局变量errno进行传递，至于返回的char *是什么？我们猜测应该就是如同上面那个 Permission denied   (权限不够)这样的提示字符串把。

更改上面代码如下：

#include <unistd.h>
#include <stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<string.h>
int main(void)
{
  int fd=open("virtul_file",O_WRONLY);
  if(fd<0)
  {
    printf("***#yangguang#***:%s
",strerror(errno));
  }
  printf("fd=%d
",fd);
  return 0;
}

可以看到，输出信息和上面一样。这样我们应该清楚了这个流程。

回到阻塞与否话题——非阻塞读终端：

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include<stdio.h>
#define MSG_TRY "try again
"
int main(void)
{
  char buf[10];
  int fd, n;
  fd = open("/dev/tty", O_RDONLY|O_NONBLOCK);//打开终端，以只读非阻塞的方式
    if(fd<0) {
      perror("open /dev/tty");
      exit(1);
    }
  tryagain:
  n = read(fd, buf, 10);//在终端读10个字节到buf缓冲区，可以少于10个，遇到回车停止读取
  if (n < 0) {//如果读取失败
    if (errno == EAGAIN) {//EAGAIN 表示try again，可以grep查询
      sleep(1);
      write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY));//写MSG_TRY到标准输出
      goto tryagain;
    }
    perror("read /dev/tty");
    exit(1);
    }
    write(STDOUT_FILENO, buf, n);//把读到的数据写在标准输出
    close(fd);
return 0;
}

不阻塞会立即读取。。。

以下是用非阻塞I/O实现等待超时的例子。既保证了超时退出的逻辑又保证了有数据到达时处理延迟较小。

非阻塞读终端和等待超时：

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include<stdio.h>
#define MSG_TRY "try again
"
#define MSG_TIMEOUT "timeout
"
int main(void)
{
  char buf[10];
  int fd, n,i;
  fd = open("/dev/tty", O_RDONLY|O_NONBLOCK);//打开终端，以只读非阻塞的方式
    if(fd<0) {
      perror("open /dev/tty");
      exit(1);
    }
 for(i=0;i<5;i++)
  {
    n = read(fd, buf, 10);//在终端读10个字节到buf缓冲区，可以少于10个，遇到回车停止读取
    if (n > 0) //如果读取成功,跳出
          break;
      if (errno != EAGAIN) 
      {//EAGAIN 表示try again，可以grep查询
          perror("read /dev/tty");
          exit(1);
      }
      sleep(1);
      write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY));//写MSG_TRY到标准输出
      
  }
  if(i==5)//5s等待都没读取到，终端显示超时
       write(STDOUT_FILENO, MSG_TIMEOUT, strlen(MSG_TIMEOUT));
  else
       write(STDOUT_FILENO, buf, n);//把读到的数据写在标准输出
    close(fd);
return 0;
}

5s不输入，显示超时：

有输入时：

由于是非阻塞的，读取会有延时，而且不能保证输入之后不打印try again就立即输出，可以看到上面出现了一次try again，所以IO默认设置成阻塞的是更具有现实意义一点。

使用grep查找内容：