【Linux系统编程】深入剖析：四大IO模型机制与应用（阻塞、非阻塞、多路复用、信号驱动IO 全解读）

fcntl函数
声明: int fcntl (int fd, int cmd,  ...arg);
头文件: #include<fcntl.h> #include<unistd.h>
功能：设置文件描述符的属性
参数：fd：文件描述符
         cmd: 操作功能选项 (可以定义个变量,通过vi -t F_GETFL 来找寻功能赋值 )
          F_GETFL:获取文件描述符的状态信息 
               //不需要第三个参数，返回值为获取到的属性
          F_SETFL:设置文件描述符的状态信息 - 需要填充第三个参数
             //需要填充第三个参数  O_RDONLY, O_RDWR ,O_WRONLY ,O_CREAT
                                                 O_NONBLOCK 非阻塞   O_APPEND追加
                                                  O_ASYNC 异步   O_SYNC  同步 
                                               O_NOATIME 读取文件时不更新文件访问时间
         arg:文件描述符的属性   如果需要设置文件描述符的状态,则需要该参数
返回值: 特殊选择:根据功能选择返回 (int 类型)   
            其他:  成功０   失败: -1;

使用:  int flag；
 // 1.获取该文件描述符0 (标准输入) 的原属性 ：标准输入原本具有阻塞的功能  
int flag = fcntl(0, F_GETFL); //获取文件描述符原有信息后，保存在flag变量内
 // 2.修改对应的位nonblock(非阻塞)
int flag |= O_NONBLOCK;  ( flag = flag | O_NONBLOCK)
 // 3. 将修改好的属性写回去 (0 标准输入 -- 阻塞  改为  非阻塞)
 fcntl (0, F_SETFL, flag); //文件描述符   设置状态  添加的新属性

//1.设置将APP进程号提交给内核驱动
fcntl(fd,F_SETOWN,getpid());//F_SETOWN将进程号交给内核驱动  
                            //getgid 进程号
//2.设置异步通知
    int flags;
    flags = fcntl(fd, F_GETFL); //获取原属性
    flags |= O_ASYNC;       //设置异步   O_ASUNC 通知
    fcntl(fd, F_SETFL, flags);  //修改的属性设置进去
//3.signal捕捉SIGIO信号 --- SIGIO:信号驱动,自定义信号驱动
signal(SIGIO,handler);

头文件： #include <signal.h>
       typedef void (*sighandler_t)(int);
       sighandler_t   signal(int signum, sighandler_t handler)
功能：信号处理函数(注册信号)
参数： int signum：要处理的信号(要修改的信号)
      sighandler_t handler: 函数指针： void(*handler)(int) (修改的功能：)
      SIG_IGN：忽略该信号。
      SIG_DFL：采用系统默认方式处理信号。
      handler：------void handler(int num) 自定义的信号处理函数指针
返回值：成功：设置之前的信号处理方式
失败：SIG_ERR

#include<sys/select.h>
#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);

struct timeval {
   long tv_sec; // 秒
   long tv_usec; // 微秒
};

1int poll(struct pollfd *fds, nfds_t nfds, int timeout);
2#include <poll.h>

1struct pollfd {
2   int fd;         // 文件描述符
3   short events;   // 关注的事件类型
4   short revents;  // 实际发生的事件
5};

1int epoll_create(int size);

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

1int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

头文件:  #include<sys/select.h>   #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);

功能：监测是哪些文件描述符产生事件;,阻塞等待产生.

参数：nfds：    监测的最大文件描述个数(文件描述符从0开始,这里是个数,记得+1)
         readfds：  读事件集合;        // 键盘鼠标的输入,客户端连接都是读事件
         writefds： 写事件集合;        //NULL表示不关心
         exceptfds：异常事件集合;  //NULL 表示不关心
         timeout：   超时检测           //如果不做超时检测：传 NULL
超时时间检测： 当程序执行到该语句时，我们设定好时间，如果规定时间   内未完成函数功能， 返回一个超时的信息，我们可以根据该信息设定相应需求；

返回值：  <0 出错            >0 表示有事件产生;
               ------------  如果设置了超时检测时间：&tv  ------------
         <0 出错            >0 表示有事件产生;      ==0 表示超时时间已到;        

超时时间检测的结构体如下:                     
            struct timeval {
               long    tv_sec;         以秒为单位,指定等待时间
               long    tv_usec;        以毫秒为单位,指定等待时间  1s = 1000us
           };
          struct timespec {
               long    tv_sec;        以秒为单位
               long    tv_nsec;       以纳秒为单位  1s = 1000000ns
           };

声明:int poll(struct pollfd *fds, nfds_t nfds, int timeout);
头文件: #include<poll.h>
功能: 监视并等待多个文件描述符的属性变化
参数：
1. struct pollfd *fds:   关心的文件描述符数组,大小自己定义
若想检测的文件描述符较多,则建立结构体数组struct pollfd fds[N]; 
           struct pollfd{
	                  int fd;	 //文件描述符
	             short events;	//等待的事件触发条件----POLLIN读时间触发
	             short revents;	//实际发生的事件(未产生事件: 0 ))
                }
2.  nfds:    最大文件描述符个数
3.  timeout： 超时检测 (毫秒级)：1000 == 1s      如果-1，阻塞     如果0,不阻塞

返回值：  <0 出错		>0 表示有事件产生;
              如果设置了超时检测时间：&tv
              <0 出错		>0 表示有事件产生;	      ==0 表示超时时间已到;

声明: int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
功能：等待事件的产生，类似于select的用法
参数: 	epfd:句柄；
		events：用来保存从链表中拿取响应事件的集合；
		maxevents:  表示每次在链表中拿取响应事件的个数；
		timeout：超时时间，毫秒级别，0立即返回  ，-1阻塞	

返回值:    < 0 出错     >0 实际从链表中拿出的数目
             如果设置了超时检测： 
               < 0出错      >0实际从链表中拿出的数目    ==0 表示超时或者没事件产生

头文件:      #include<sys.socket.h> 
            #include<sys/types.h>
            #include<sys/time.h>
int setsockopt(int sockfd,int level,int optname,void *optval,socklen_t optlen)
功能：获得/设置套接字属性
参数：
sockfd：套接字描述符
level：协议层
optname：选项名
optval:选项值
optlen:选项值大小
返回值：   成功： 0               失败 -1

设置 接收超时
设置超时检测操作的结构体:  
struct timeval {
long tv_sec; /*秒*/
long tv_usec; /*微秒*/
};

struct timeval tm={2,0}; 
setsockopt(acceptfd,SOL_SOCKET,SO_RCVTIMEO,&tm,sizeof(tm));
//设置超时之后时间一旦到达,会打断接下来的阻塞，直接错误返回
int recvbyte = recv(acceptfd, .......);

设置端口和地址重用(在绑定bind上面写)
int optval=1; 
setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&optval,sizeof(optval));

头文件: #include <signal.h>
声明:   int sigaction(int signum, const struct sigaction *act,  struct sigaction *oldact);
功能：对接收到的指定信号处理   
参数:   1. signum  信号	

     2. //act为设置新行为   oldact为设置旧行为 

            结构体如下:  
               struct sigaction {     
                    void     (*sa_handler)(int); //函数指针
                    其他的结构体成员如mark(信号集)，flag(对信号的标记)都不常用
               };

		===============需要定义一个函数接收====================

	    void handler()
		{
			printf("timeout .....\n");
		}   

一般，给目标设置新的属性，流程都为：  
      先获取原来的属性
      修改属性
      将属性写回去


#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void handler(int sig)
{
    printf("1111111\n");
}


int main(int argc, const char *argv[])
{
  //1.定义结构体变量
	struct sigaction act;
  //2.获取原来的属性
   sigaction(SIGALRM,NULL,&act);
  //3.修改属性
   act.sa_handler = handler;
  //4.写回属性
  sigaction(SIGALRM,&act,NULL);

   char buf[128] = ""; 
	while(1)
	{
	    alarm(2);  
	  if(fgets(buf,sizeof(buf),stdin) == NULL)
	  {
	       perror("fgets is err:");
		   continue;
	  }
	  printf("!!!!!!!\n");
	}
	return 0;
}